Apple déploie une préversion de Swift 4.1 avec la bêta de XCode 9.3
Le langage apporte la conformité conditionnelle

Le , par Stéphane le calme, Chroniqueur Actualités
En octobre 2017, Apple a dévoilé la feuille de route de Swift 4.1, dont la version stable est attendue « dans la première moitié de 2018 » :
  • 18 octobre 2017 (branchement initial) : swift-4.1-branch sera initialement coupée du master ;
  • environ toutes les deux semaines, master va fusionner avec swift-4.1-branch jusqu'à la date finale de la branche ;
  • 4 décembre 2017 (branchement final): swift-4.1-branch aura des changements fusionnés du master une dernière fois. Après cette date finale de la branche, il y aura une période durant laquelle seules les corrections critiques choisies entreront dans la version finale (via des pull request).

Conformément à ce calendrier, Apple a donc déployé la première préversion de Swift 4.1 dans la bêta de Xcode 9.3. Voici quelques-unes des fonctionnalités qui sont proposées.

Support synthétisé des protocoles Equatable et Hashable

Le protocole Equatable permet à Swift de comparer une instance d'un type à une autre. Par exemple, lorsque nous déclarons que 5 == 5, Swift comprend ce que cela signifie parce que Int se conforme à Equatable, ce qui signifie qu'il implémente une fonction décrivant ce que signifie == pour deux instances de Int.

Implémenter Equatable dans nos propres types de valeurs leur permet de fonctionner comme les chaînes, les tableaux, les nombres de Swift, etc., et c'est généralement une bonne idée de rendre vos structures conformes à Equatable juste pour qu'elles correspondent mieux au concept des types de valeur.

Cependant, l'implémentation de Equatable peut être contraignante. Dans le code suivant :

Code Swift : Sélectionner tout
1
2
3
4
5
6
struct Person {
    var firstName: String
    var middleName: String
    var age: Int
    var city: String
}

Si vous avez deux instances de Person et que vous voulez vous assurer qu'elles sont identiques, vous devez comparer les quatre propriétés, comme ceci :

Code Swift : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
struct Person: Equatable {
    var firstName: String
    var lastName: String
    var age: Int
    var city: String
 
    static func ==(lhs: Person, rhs: Person) -> Bool {
        return lhs.firstName == rhs.firstName && lhs.lastName == rhs.lastName && lhs.age == rhs.age && lhs.city == rhs.city
    }
}

Vous en conviendrez, même la lecture n’est pas très agréable.

Avec Swift 4.1, il est possible de synthétiser la conformité pour Equatable, c’est-à-dire que Swift 4.1 peut générer automatiquement une méthode ==, qui compare toutes les propriétés d'une valeur avec toutes les propriétés d'une autre, comme ci-dessus. Tout ce que vous avez à faire est simplement d'ajouter Equatable comme un protocole pour votre type, et Swift fera le reste.

Et pour ceux qui tiennent à implémenter le == eux-mêmes, bien entendu cela reste possible. Par exemple, si votre type a un champ id qui l'identifie de manière unique, vous aurez à écrire == pour comparer cette valeur unique plutôt que de laisser Swift faire tout le travail supplémentaire.

Swift 4.1 introduit également un support synthétisé pour le protocole Hashable, ce qui signifie qu'il va générer automatiquement une propriété hashValue pour les types conformes. Hashable demandait de toujours retourner un hachage unique (ou au moins principalement unique) pour chaque objet.

Avant vous deviez écrire :

Code Swift : Sélectionner tout
1
2
3
var hashValue: Int {
    return firstName.hashValue ^ lastName.hashValue &* 16777619
}

Pour la plupart des cas, ce n'est plus nécessaire dans Swift 4.1.

Conformité conditionnelle

La Swift Evolution SE-0143 a proposé des conformations conditionnelles, et elle a maintenant été implémentée dans Swift 4.1. C'est une fonctionnalité puissante que la plupart des gens utiliseront indirectement – les choses qui n'ont pas fonctionné auparavant vont fonctionner désormais. Par exemple, le code suivant ne sera pas compilé avec Swift 4.0 :

Code Swift : Sélectionner tout
1
2
3
var left: [String?] = ["Andrew", "Lizzie", "Sophie"]
var right: [String?] = ["Charlotte", "Paul", "John"]
left == right

C'est parce que String et [String] sont équitables, mais [String?] Ne l'était pas. La conformité conditionnelle signifie qu'il est maintenant possible d'ajouter une conformité de protocole à un type tant qu'il satisfait une condition - dans ce cas, si les éléments du tableau sont equatables, cela signifie que l'ensemble est équivalent.

La conformité conditionnelle a été étendue au protocole Codable d'une manière qui rendra certainement les choses plus sûres. Considérez ce code :

Code Swift : Sélectionner tout
1
2
3
4
5
6
7
struct Person {
    var name = "Taylor"
}
 
var people = [Person()]
var encoder = JSONEncoder()
try encoder.encode(people)

Cela crée un tableau avec une seule personne à l'intérieur, puis tente de l'encoder en JSON. Ce code se compile proprement sur Swift 4.0, mais renvoie une erreur fatale au moment de l'exécution, car Person n'est pas conforme à Codable. Swift 4.1 nettoie ceci : Optionnel, Array, Dictionary, et Set ne sont maintenant conformes à Codable que si leur contenu est également conforme à Codable, donc le code ci-dessus refusera de compiler.

Source : blog Swift, HackingSwift, GitHub (1, 2)

Et vous ?

Quelles sont les fonctionnalités qui vous intéressent le plus ?


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :
Contacter le responsable de la rubrique Accueil