L'équipe en charge du développement de Swift vient d'annoncer la disponibilité générale de Swift 6. Cette nouvelle version majeur de Swift apporte de nouvelles fonctionnalités de programmation de bas niveau, un sous-ensemble de langage Swift intégré, une prise en charge étendue de Linux et de Windows, de nouvelles API multiplateformes, notamment la nouvelle bibliothèque Swift Testing, et bien d'autres choses encore.Swift est un langage de programmation compilé de haut niveau, polyvalent et multi-paradigme, créé par Chris Lattner en 2010 pour Apple Inc. et maintenu par la communauté open-source. Swift se compile en code machine et utilise un compilateur basé sur LLVM. Swift a été publié pour la première fois en juin 2014 et la chaîne d'outils Swift est intégrée à Xcode depuis la version 6.
En 2020, l'équipe en charge du développement de Swift avait dévoilé la nouvelle feuille de route du projet vers la version 6. L'équipe de Swift a confirmé que Swift 6 est la prochaine itération majeure du langage après les versions 5.x. Swift 6 serait également plus axée sur le Machine Learning afin notamment de préparer l’intégration plus poussée de ce langage de programmation aux opérations en relation avec l’intelligence artificielle (IA), mais aussi "l'autonomisation de l’utilisateur".
Ce 17 Septembre, l'équipe de Swift vient d'annoncer la disponibilité générale de Swift 6. De nombreuses personnes connaissent Swift en tant que langage de développement d'applications, avec un million d'applications sur l'App Store. Mais Swift n'est pas seulement utile pour les applications. La sécurité, la vitesse et l'accessibilité de Swift en font un excellent choix pour de nombreux autres cas d'utilisation, notamment les bibliothèques, les services à l'échelle de l'internet et le code le plus critique en termes de performances et de sécurité.
Swift 6 va encore plus loin grâce à de nouvelles fonctionnalités de programmation de bas niveau, un sous-ensemble de langage Swift intégré, une prise en charge étendue de Linux et de Windows, de nouvelles API multiplateformes, notamment la nouvelle bibliothèque Swift Testing, et bien d'autres choses encore. Swift 6 apporte des changements au langage, aux bibliothèques standard, au débogage, à la prise en charge des plates-formes.
Voici quelques améliorations dans Swift 6 :
Concurrence
Swift offre depuis longtemps une sécurité de la mémoire, garantissant que les variables sont initialisées avant d'être utilisées, que la mémoire n'est pas accessible après avoir été désallouée et que les indices de tableau sont vérifiés pour les erreurs hors limites. Swift 6 inclut désormais un nouveau mode de langage optionnel qui étend les garanties de sécurité de Swift pour prévenir les courses de données dans le code concurrent en diagnostiquant les courses de données potentielles dans votre code comme des erreurs du compilateur.
Les contrôles de sécurité des courses de données (data-race) étaient auparavant disponibles sous forme d'avertissements dans Swift 5.10 grâce à l'option de compilation -strict-concurrency=complete. Grâce à l'amélioration de l'inférence Sendable et à la nouvelle analyse du compilateur pour le transfert d'un état mutable d'un acteur à un autre, les avertissements de Swift 6 concernant la sécurité des data-race ont moins de faux positifs.
Swift 6 marque le début d'un parcours visant à faciliter considérablement la sécurité des données. La facilité d'utilisation de la sécurité des données reste un domaine de développement actif pour le langage Swift.
Swift 6 s'accompagne également d'une nouvelle bibliothèque de synchronisation pour les API de concurrence de bas niveau, y compris les opérations atomiques et une nouvelle API mutex.
Fonctions typées "throws"
Swift 6 permet aux fonctions de spécifier le type d'erreur qu'elles lancent dans le cadre de leur signature. Cette fonctionnalité est utile dans le code générique qui transmet les erreurs lancées dans le code client, ou dans les environnements à ressources limitées qui ne peuvent pas allouer de mémoire, comme dans le code Swift intégré.
Exemple :
| Code : | Sélectionner tout |
1 2 3 | func parseRecord(from string: String) throws(ParseError) -> Record {
// ...
} |
| Code : | Sélectionner tout |
1 2 3 4 5 | do {
let record = try parseRecord(from: myString)
} catch {
// 'error' has type 'ParseError'
} |
Les fonctions typées "throws" peuvent également être utilisés dans les fonctions génériques pour propager les types d'erreur à partir des paramètres, d'une manière plus précise que les rethrows. Par exemple, la méthode Sequence.map peut propager le type d'erreur jeté à partir de son paramètre de fermeture, indiquant qu'elle ne jette que le même type d'erreurs que la fermeture :
| Code : | Sélectionner tout |
1 2 3 4 5 | extension Sequence {
func map<T, E>(_ body: (Element) throws(E) -> T) throws(E) -> [T] {
// ...
}
} |
Propriété
Swift 5.9 a introduit les types non copiables avec la syntaxe ~Copyable pour modéliser les ressources avec une propriété unique, et écrire du code plus performant en éliminant la surcharge d'exécution associée à la copie. Swift 6 prend désormais en charge ces types avec le système générique, ce qui permet d'écrire du code générique qui fonctionne avec des types copiables et non copiables.
Exemple :
| Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 | protocol Drinkable: ~Copyable {
consuming func use()
}
struct Coffee: Drinkable, ~Copyable { /* ... */ }
struct Water: Drinkable { /* ... */ }
func drink(item: consuming some Drinkable & ~Copyable) {
item.use()
}
drink(item: Coffee())
drink(item: Water()) |
Il est désormais possible d'écrire des instructions de commutation pour éviter la copie dans les opérations de comparaison de motifs des enums. Cela signifie que les instructions switch peuvent être utilisées avec des données utiles non copiables et qu'elles peuvent également offrir des avantages en termes de performances pour les données utiles copiables, en particulier celles qui sont basées sur des conteneurs de copie en écriture comme Array et Dictionary.
Les types non copiables sont déjà utilisés dans les bibliothèques standard. Par exemple, le nouveau type Atomic de la bibliothèque Synchronisation est basé sur ~Copyable, Optional et Result peuvent désormais envelopper des types non copiables, et les types de pointeurs de tampons non sûrs peuvent désormais pointer vers des éléments non copiables. L'interopérabilité C++ utilise également des types non copiables pour exposer les types C++ à déplacement unique à Swift.
Interopérabilité C++
Swift 5.9 a introduit l'interopérabilité bidirectionnelle avec le C++ afin d'intégrer Swift à un plus grand nombre de projets existants. Swift 6 étend la prise en charge de l'interopérabilité aux types C++ à déplacement unique, aux méthodes virtuelles, aux arguments par défaut et à d'autres types de la bibliothèque standard, notamment std::map et std::optional.
Les types C++ qui n'ont pas de constructeur de copie sont désormais accessibles depuis Swift 6 en tant que types non copiables avec ~Copyable. Et pour les cas où il est utile d'exposer un type C++ avec un constructeur de copie en tant que ~Copyable dans Swift pour de meilleures performances, une nouvelle annotation SWIFT_NONCOPYABLE peut être appliquée au type C++.
Swift prend désormais également en charge les appels de méthodes virtuelles C++ sur les types annotés SWIFT_SHARED_REFERENCE ou SWIFT_IMMORTAL_REFERENCE.
Lors de l'appel de fonctions ou de méthodes C++ ayant des valeurs d'argument par défaut pour certains de leurs paramètres, Swift respecte désormais ces valeurs par défaut, au lieu de vous demander de passer explicitement un argument.
Swift embarqué
Swift 6 comprend un aperçu de "Swift embarqué" (Embedded Swift), un sous-ensemble de langage et un mode de compilation adaptés au développement de logiciels embarqués, tels que la programmation de microcontrôleurs. La chaîne d'outils prend en charge les cibles ARM et RISC-V bare-metal.
"Swift embarqué" produit de petits binaires autonomes en s'appuyant sur la spécialisation générique. Comme il ne s'appuie pas sur un runtime ou des métadonnées de type, "Swift embarqué" est adapté aux plates-formes à faibles contraintes de mémoire ainsi qu'à une utilisation dans des environnements de bas niveau avec des dépendances de runtime limitées.
"Swift embarqué" reste une fonctionnalité expérimentale, en cours de développement avant une prise en charge stable dans une prochaine version de Swift.
Intégration 128 bits
Swift 6 complète l'ensemble des primitives entières de bas niveau avec l'ajout de types d'entiers signés et non signés de 128 bits. Ceux-ci sont disponibles sur toutes les plateformes Swift et fournissent la même API que les autres types d'entiers à largeur fixe de la bibliothèque standard.
Améliorations de la productivité
Swift 6 introduit un certain nombre d'améliorations de la productivité, notamment count(where :) pour rationaliser le comptage du nombre d'éléments d'une séquence qui satisfont un prédicat, "pack iteration" pour écrire des boucles for naturelles sur les éléments d'un pack de paramètres de valeur, contrôle d'accès pour les importations afin d'empêcher les détails de l'implémentation de fuir dans vos API publiques, macros @attached(body) pour synthétiser et augmenter les implémentations de fonctions, macros d'expression en tant qu'arguments par défaut, et bien plus encore.
Amélioration des performances de démarrage avec les modules explicites
Swift 6 améliore considérablement les performances de démarrage du débogueur lorsque vous utilisez des modules explicites. Lors du débogage de...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.