Fermeture tuple ne prend pas en charge déstructuration dans Xcode 9 Swift 4

Après le brillant de projet pour Swift 4 dans Xcode 9

Je suis d'erreur suivant qui je n'ai aucune idée de

Fermeture tuple paramètre(clé: _, valeur: _) ne prend pas en charge
déstructuration

Code:

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)
        }))
    }
}

Erreur est à ce point try flatMap({ (key, value)in

Dictionary.init(elements:) ne peut pas être trouvé dans la Swift de la Bibliothèque Standard. Vous définissez vous-même?
Oui, je suis la mise à jour de la réponse
j'ai mis à jour la réponse

InformationsquelleAutor mihir mehta | 2017-07-06

23

Commençons par la définition de flatMap pour un dictionnaire qui est la suivante:
```
func flatMap(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
```
Vous voyez que le transform fermeture ne prend que un paramètre de type Element où Element est juste un typealias pour un n-uplet:
```
public typealias Element = (key: Key, value: Value)
```
Donc la première et seulement argument de la clôture doit être un tuple de deux éléments (key de type Key et value de type Value).

Maintenant, si vous regardez votre code (qui compile en Swift 3), vous verrez que ce n'est pas le cas, et vous devriez vous demander pourquoi ce même travail dans Swift 3.
```
try flatMap({ (key, value) in
    return try transform(key, value)
})
```
Votre fermeture prend 2 arguments au lieu d'une (key de type Key et value de type Value). Cela fonctionne dans Swift 3 grâce à une fonctionnalité appelée déstructuration où le compilateur de transformer automatiquement un tuple de 2 éléments en 2 arguments.

~~Mais cette fonctionnalité est bizarre, rarement utilisé et donne des résultats inattendus, la plupart du temps de sorte qu'il a été supprimé en Swift 4.~~

Modifier: Comme l'a souligné OOPer, cette fonctionnalité a été retirée temporairement dans Swift 4 bêta, mais doit être ajouté avant la version finale est sortie.

Au lieu que vous devriez écrire:
```
try flatMap({ tupleArgument in
    return try transform(tupleArgument.key, tupleArgument.value)
})
```
Et votre flatMap fonction devient:
```
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)
    }))
}
```
- Merci pour l'explication. C'est la troisième partie de la bibliothèque que j'essaie de la rendre compatible avec swift4.
InformationsquelleAutor deadbeef
6

C'est un effet secondaire de cette proposition de Swift 4:

SE-0110 Distinguer entre un seul n-uplet et multiple de l'argument des types de fonction.

Mais certaines fonctionnalités incluses dans cette proposition a causé quelques régression dont il est question dans ce post de la évolution-liste de diffusion d'annonces:

[swift-evolution-announce] [Noyau de l'équipe] Abordant le SE-0110 de l'utilisabilité de la régression Swift 4

Vous pouvez vous attendre dans le futur bêta ou GM version de Xcode 9, votre code ne compile bien de nouveau. D'ici là, vous pouvez utiliser ce genre de solution:
```
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)
    }))
}
```
Par la façon dont, dans Swift 4, Dictionary a quelques nouvelles des initialiseurs qui prennent Sequence de (Key, Value) paire. Par exemple:

init(uniqueKeysWithValues: S)

InformationsquelleAutor OOPer
2

Je viens de rencontré cette erreur résulte de l'utilisation de enumerated().map():

Fermeture tuple paramètre ne prend pas en charge déstructuration

J'ai tapé le code:
```
["foo"].enumerated().map(
```
Et puis gardé en appuyant sur Entrée jusqu'à ce que Xcode complété automatiquement la fermeture réutilisable.

La saisie semi-automatique a apparemment un bug qui provoque l'erreur ci-dessus. La saisie semi-automatique de produit de la double parenthèse ((offset: Int, element: String)), plutôt que des parenthèses (offset: Int, element: String).

J'ai corrigé manuellement et a été en mesure de continuer:
```
//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"
}
```
Peut-être le résultat de l'utilisation de Xcode 10.0 beta (10L176w)

InformationsquelleAutor pkamb

Vous devez vous connecter pour publier un commentaire.