destrutturazione tupla di tuple in chiusura

Question

posso destrutturare una tupla di tuple facilmente:

let tt = (2, (3, 4)) 

let (a, (b, c)) = tt 
b // => 3 

mi piacerebbe fare la stessa cosa quando si dichiara una chiusura, per esempio ho pensato che avrei potuto scrivere:

[tt].map { (a, (b, c)) in 
    // Use b 
} 

XCode si lamenta con "I parametri senza nome devono essere scritti con il nome vuoto".

unico modo che ho ottenuto al "lavoro" era:

[tt].map { (a, tuple: (b: Int, c: Int)) in 
    // Use tuple.b 
} 

Questo ha due svantaggi mi piacerebbe evitare:

• ho bisogno di usare tuple.b invece di b
• Devo specificare i tipi di b e c

BTW, il mio caso d'uso è che io voglio fare un reduce con indice in modo che sto cercando utilizzando array.enumerate().reduce

Answer 1

Questo soddisfa il vostro primo requisito, ma ancora richiedono di aggiungere tipo annonation:

typealias TupleType = (a: Int, tuple: (b: Int, c: Int)) 

let tt: TupleType = (2, (3, 4)) 

[tt].map { 
    print($0.tuple.b) 
} 

Answer 2

Con un riga di assegnazione aggiuntiva, è possibile assegnare i valori nella matrice di (a, (b, c)) decostruire tupla:

let tt1 = (2, (3, 4)) 
let tt2 = (5, (6, 7)) 

[tt1, tt2].map { tt in 
    let (a, (b, c)) = tt 
    print(b) 
} 

uscita:

012.

3 
6 

---

alternativa:

[tt1, tt2].map { 
    let (a, (b, c)) = $0 
    print(b) 
} 

Answer 3

Un'altra soluzione:

[tt].map { a, b in 
    let (b, c) = b 
    print(a, b, c) 
}