ios - color - La tupla de cierre no admite la desestructuración en Xcode 9 Swift 4

menu ios

Question

Después del proyecto de brillo para Swift 4 en Xcode 9

Estoy recibiendo error siguiente que no tengo idea

El parámetro de tupla de cierre ''(clave: _, valor: _)'' no admite la desestructuración

Código:

extension Dictionary
{
    init(elements: [Element]) {
        self.init()
        for (key, value) in elements {
            self[key] = value
        }
    }

    func flatMap<KeyPrime, ValuePrime>(_ transform: (Key, Value) throws -> (KeyPrime, ValuePrime)?) rethrows -> [KeyPrime:ValuePrime] {
        return Dictionary<KeyPrime, ValuePrime>(elements: try flatMap({ (key, value) in
            return try transform(key, value)
        }))
    }
}

El error llega en este punto, try flatMap({ (key, value)in

Answer 1

Acabo de encontrar este error como resultado del uso de enumerated().map() :

El parámetro de tupla de cierre no admite la desestructuración

Escribí el código:

["foo"].enumerated().map(

Y luego siguió presionando Intro hasta que Xcode completó automáticamente la placa de cierre.

El autocompletar aparentemente tiene un error que causa el error anterior. El autocompletado produce paréntesis doble ((offset: Int, element: String)) lugar de paréntesis simple (offset: Int, element: String) .

Lo arreglé manualmente y pude continuar:

// Xcode autocomplete suggests:
let fail = ["foo"].enumerated().map { ((offset: Int, element: String)) -> String in
    return "ERROR: Closure tuple parameter does not support destructuring"
}

// Works if you manually replace the "(( _ ))" with "( _ )"
let pass = ["foo"].enumerated().map { (offset: Int, element: String) -> String in
    return "works"
}

Posiblemente el resultado de usar Xcode 10.0 beta (10L176w)

Answer 2

Comencemos con la definición de flatMap para un diccionario que es el siguiente:

func flatMap(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

Verá que el cierre de transform toma solo un parámetro de tipo Element donde Element es solo una typealias de una tupla:

public typealias Element = (key: Key, value: Value)

Entonces, el primer y único argumento del cierre debe ser una tupla de dos elementos ( key de tipo Key y value de tipo Value ).

Ahora, si observa su código (que se compila en Swift 3), verá que este no es el caso, y debería preguntarse por qué funciona esto en Swift 3.

try flatMap({ (key, value) in
    return try transform(key, value)
})

Su cierre toma 2 argumentos en lugar de uno ( key de tipo Key y value de tipo Value ). Esto funciona en Swift 3 gracias a una característica llamada desestructuración donde el compilador transformará automáticamente una tupla de 2 elementos en 2 argumentos.

Pero esta característica es rara, rara vez se usa y da resultados inesperados la mayor parte del tiempo por lo que se ha eliminado en Swift 4.
Edición : Como lo señaló OOPer, esta función se ha eliminado temporalmente en Swift 4 beta, pero debe volver a agregarse antes de que salga la versión final.

En su lugar deberías estar escribiendo:

try flatMap({ tupleArgument in
    return try transform(tupleArgument.key, tupleArgument.value)
})

Y tu función flatMap convierte en:

func flatMap<KeyPrime, ValuePrime>(_ transform: (Key, Value) throws -> (KeyPrime, ValuePrime)?) rethrows -> [KeyPrime:ValuePrime] {
    return Dictionary<KeyPrime, ValuePrime>(elements: try flatMap({ element in
        return try transform(element.key, element.value)
    }))
}

Answer 3

Es un efecto secundario de esta propuesta para Swift 4:

SE-0110 Distinguir entre tipos de función de tupla simple y argumento múltiple .

Pero algunas de las características incluidas en esta propuesta causaron cierta regresión que se aborda en esta publicación de la lista de correo de evolución-anuncio :

[anuncio-evolución-rápida] [equipo central] Aborda la regresión de usabilidad SE-0110 en Swift 4

Por lo tanto, puede esperar que en la futura versión beta o GM de Xcode 9, su código se compile nuevamente. Hasta entonces, puede utilizar este tipo de solución:

internal func flatMap<KeyPrime , ValuePrime>(_ transform: (Key, Value) throws -> (KeyPrime, ValuePrime)?) rethrows -> [KeyPrime : ValuePrime] {
    return Dictionary<KeyPrime,ValuePrime>(elements: try flatMap({ pair in
        let (key, value) = pair
        return try transform(key, value)
    }))
}

Por cierto, en Swift 4, Dictionary tiene algunos inicializadores nuevos que toman el par de Sequence de (Key, Value) . Por ejemplo:

init (uniqueKeysWithValues: S)