Swift: Unable to decompose tuple in certain closures (e.g., reduce with enumerate)?

Question

When using map() with enumerate(), Swift will decompose the enumerate tuple:

map(enumerate([1,2,3])) { (index, element) in
    index + element
}

Answer 1

The answer is "Swift simply not allow it". You can't decompose nested tuple like that.

For example, this code compiles, but we cannot access j or k:

func foo(i: Int, (j: Int, k: Int) ) {
    // println(j)
    //         ^ error: use of unresolved identifier 'j'
}
foo(1, (2, 3))

Because, in this code, (j: Int, k: Int) is just a type, and the received tuple itself does not have a name. You have to write like this instead:

func foo(i: Int, x: (j: Int, k: Int) ) {
    println(x.j)
}
foo(1, (1, 2))

In the same way, this compiles, but it's useless.

reduce(enumerate([12,42,84]), 0) { (accum, (index:Int, element:Int)) in

Instead, you have to receive the tuple itself, then decompose it if you want:

reduce(enumerate([12,42,84]), 0) { (accum, enumerated)  in
    println(enumerated.element)

    let (index, element) = enumerated