swift - 区分元组和多参数函数

Question

我在 playground 中编写了这个函数，它具有元组类型的 value 参数并且返回类型是元组。

func tuple(value: (Int, Int) ) -> (first: Int, second: Int) {
    let firstGrabTuple = value.0 + 5
    let secondGrabTuple = value.1 + 5
    return (firstGrabTuple, secondGrabTuple)
}

然后我将它分配给名为 closure 的常量

let closure = tuple
//(Playground showing) let closure became a function of type (Int, Int) -> (first: Int, second: Int)

然后为了仔细检查，我编写了另一个以闭包为参数的函数，类型为 ((Int, Int)) -> (Int, Int)

func anotherTuple(_ closure: ((Int, Int)) -> (Int, Int)) {
    closure((5, 5))
}

当我调用anotherTuple

anotherTuple { (x) -> (Int, Int) in
    let first = x.0 + 5
    let second = x.1 + 5
    return (first, second)
}
//prints .0 10, .1 10 as expected

所以我的问题如上所述，当第一个函数 tuple 我将它分配给名为 closure 的常量时，类型变为 (Int, Int) -> (first : Int, second: Int).但是在第二个函数中，如果我必须使用元组类型的参数，我必须将其参数设置在双括号中，如 (_ closure: ((Int, Int)) -> (Int, Int)).

但是如果我从 anotherTuple 函数参数中删除那些双括号，那么它将只期望 2 个值作为多参数函数。用作多参数函数而不是元组参数没有错误这是为什么？添加图像以获取更多详细信息。第二个问题是为什么

let closure = tuple
  //let closure became a function of type (Int, Int) -> (first: Int, second: Int)

没有变成 ((Int, Int)) -> (first: Int, second: Int)

**注意 - 当我试图将名为 closure 的常量作为参数传递给另一个函数时，该函数期望闭包类型为 ((Int, Int)) -> (Int, Int ) 然后在键入 closure 时在自动完成代码中显示为 ((Int, Int)) -> (Int, Int)。

Answer 1

您对混淆的看法是正确的。我只是想重申一下您的理解，然后说“是的，Swift 中的元组很奇怪而且有点破损。”

Swift 不会在某些方面区分采用元组和多个参数的函数，但会在其他方面进行区分。 (这是在 Swift 生命的这个阶段避免使用元组的众多原因之一。)

首先，这两个函数在 Swift 中具有几乎相同的类型(注意 Void 和 () 是相同的):

func tuple(value: (Int, Int) ) {}      // (Int, Int) -> Void
func two(value1: Int, value2: Int) {}  // (Int, Int) -> Void

它们看起来一样。但是如果你定义了一个接受那个类型的函数，它就不能接受 tuple:

func take(f: (Int, Int) -> Void) {}
take(f: tuple)  // Fails
take(f: two)    // ok

但是如果你定义一个接受((Int, Int)) -> Void 的函数，它可以接受任何一个函数:

func take(f: ((Int, Int)) -> Void) {}
take(f: tuple)  // ok
take(f: two)    // ok

这表明 (Int, Int) -> Void 是 ((Int, Int)) -> Void 的子类型。

但变量掩盖了这一点:

var f: (Int, Int) -> Void
f = tuple   // Ok
f = two     // Ok

var g: ((Int, Int)) -> Void
g = tuple   // ok
g = two     // ok

g = f  // ok
f = g  // ok

这表明 (Int, Int) -> Void 和 ((Int, Int)) -> Void 是同一类型。但是 take 函数表明它们不是。

是的。所有这些同时都是真实的。接受元组的函数在 Swift 中不是一个连贯的类型(它们不占据类型层次结构中明确划分的位置)。这就是我们今天在 Swift 中的处境。

---

旧的、不正确的答案。

<罢工>这只是 Playgrounds 的一个怪癖，您可以随意打开 radar关于那个。

如果您检查 type(of: closure)，它将打印您期望的类型。 Swift 知道正确的类型； Playground 只是显示错误的东西。