Swift中的元组和函数参数

在以下两个示例中,函数返回相同的类型,即使一个采用元组而另一个采用两个参数.从调用者的角度来看(没有窥视代码),函数是否采用元组或常规参数没有区别.

函数参数在某些方面与元组有关吗？

例如

func testFunctionUsingTuple()->(Int,String)->Void {
    func t(x:(Int,String)) {
        print("(x.0) (x.1)")
    }

    return t
}

func testFuncUsingArgs()->(Int,String)->Void {
    func t(x:Int,y:String) {
        print("(x) (y)")
    }

    return t
}

do {
    var t = testFunctionUsingTuple()
    t(1,"test")
}

do {
    var t = testFuncUsingArgs()
    t(1,"test")
}

在常规函数(而不是返回函数)中声明函数参数中的元组时,行为也存在不一致：

func funcUsingTuple(x:(Int,String)) {
    print("(x.0) (x.1)")
}

func funcUsingArgs(x:Int,_ y:String) {
    print("(x) (y)")
}

// No longer works,need to call funcUsingTuple((1,"test")) instead
funcUsingTuple(1,"test")   
funcUsingArgs(1,"test3")

更新：

Chris Lattner对元组的澄清：

“x.0” where x is a scalar value produces that scalar value,due to odd
behavior involving excessive implicit conversions between scalars and
tuples. This is a bug to be fixed.

In “let x = (y)”,x and y have the same type,because (x) is the
syntax for a parenthesis (i.e.,grouping) operator,not a tuple
formation operator. There is no such thing as a single-element
unlabeled tuple value.

In “(foo: 42)” – which is most commonly seen in argument lists –
you’re producing a single element tuple with a label for the element.
The compiler is currently trying hard to eliminate them and demote
them to scalars,but does so inconsistently (which is also a bug).
That said,single-element labeled tuples are a thing.