L'équipe Rust a publié la version 1.56 du langage de programmation dans les délais prévus, ce qui marque également le début de la nouvelle édition Rust 2021. Les innovations les plus importantes comprennent une capture modifiée des variables dans les closures et une itération propre sous le capot sur les valeurs des tableaux au lieu des références. L'équipe a laissé entendre que l'édition 2021 du langage est petite, mais inclut quelques changements de qualité de vie.Une édition au lieu de la version principale
La version portant le numéro discret 1.56 marque le début de la troisième édition du langage de programmation après Rust 2015 et 2018, qui a été annoncée pour la première fois en mai. Les nouvelles éditions introduisent des fonctionnalités supplémentaires qui peuvent entraîner des incompatibilités avec les éditions précédentes. Toutefois, la mise à jour devrait apporter le moins de changements de rupture possible. Les éditions ne divisent pas l'écosystème. « La règle la plus importante pour les éditions est que les crates d'une édition peuvent interagir de manière transparente avec les crates compilées dans d'autres éditions », explique l'équipe.
Rust avait embarqué le pattern [C=Rust]async await[/Rust] en 2018, ce qui, par effet de bord, incluait les nouveaux mots-clés [C=Rust]async[/Rust] et [C=Rust]await[/Rust]. Cela pouvait devenir un problème si le code utilisait les termes précédemment sans réserve comme noms de variables, par exemple, ce qui est rarement le cas. Comme les changements d'une édition à l'autre sont généralement plutôt modérés, l'équipe Rust s'est prononcée contre le passage à une nouvelle version principale lors du premier saut d'édition en 2018. Ainsi, Rust 1.56 et Rust 2021 sont une seule et même version.
Les développeurs déterminent l'édition respective pour chaque crate. Par conséquent, il n'est pas nécessaire de modifier l'ancien code pour l'utiliser avec le code source de la dernière édition. Enfin, sous le capot, le compilateur crée une représentation interne uniforme pour le code mixte. « L'édition 2021 de Rust est petite, mais représente une évolution significative du langage », a déclaré Armin Ronacher, directeur de l'ingénierie chez Sentry et développeur Rust de longue date.
« Bien qu'en surface, elle semble sans conséquence, elle montre que Rust reste fidèle à sa détermination de rétrocompatibilité et évolue à un rythme régulier vers un langage de programmation système plus puissant ». Rust 2021 a apporté des améliorations aux conversions de types faillibles, a résolu quelques défauts (comme l'incapacité d'itérer sur des tableaux), a ajouté un nouveau résolveur de dépendances plus puissant, et des règles de capture de closure plus flexibles.
Les changements intervenus dans Rust 2021
Capture disjointe dans les closures
Un grand changement dans Rust 2021 concerne les closures, un concept de fonctions anonymes dans Rust qui fonctionne de manière similaire aux expressions lambda dans Kotlin, Java et C# ou aux fonctions fléchées dans JavaScript. Les closures capturent automatiquement tout ce à quoi vous faites référence à l'intérieur de leur corps. Par exemple, || a + 1 capture automatiquement une référence à a à partir du contexte environnant. Avant le traitement, les closures obtiennent du contexte une référence aux objets utilisés. La liaison des variables est appelée capturing.
À partir de Rust 2021, elles ne reçoivent que les sous-objets réellement utilisés, par exemple dans la construction || a.x + 1, uniquement le champ demandé a.x , au lieu de la structure complète a à lier. Cela signifie que l'accès est toujours possible même si un autre champ a été accédé précédemment, par exemple via drop(a.y) a été supprimé. Jusqu'à présent, cela a conduit à une erreur parce que Rust n'a plus la structure a complète à référencer, mais ce n'est pas nécessaire pour la closure dans ce cas. Voici un autre exemple :
| Code Rust : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 | // 2015 or 2018 edition code let a = SomeStruct::new(); // Move out of one field of the struct drop(a.x); // Ok: Still use another field of the struct println!("{}", a.y); // Error: Before 2021 edition, tries to capture all of `a` let c = || println!("{}", a.y); c(); |
Pour résoudre ce problème, vous auriez dû extraire quelque chose comme let y = &a.y; manuellement avant la closure pour limiter sa capture. À partir de Rust 2021, les fermetures ne captureront automatiquement que les champs qu'elles utilisent, donc l'exemple ci-dessus compilera bien.
La nouvelle procédure ne s'applique que si les développeurs activent l'édition 2021, car elle peut casser le code existant dans certains cas. Cela pourrait potentiellement changer l'ordre dans lequel les champs sont supprimés (drop)will. L'underscore peut être utilisé pour forcer l'ancien comportement dans la nouvelle édition et pour lier la structure entière : let _ = &a;.
Une valeur au lieu d'une référence
Une autre innovation s'est progressivement introduite dans Rust par rapport aux versions précédentes : l'itération sur des tableaux par valeur avec son propre trait. Rust 1.51 avait initialement introduit l'API std::array::IntoIter. Depuis la version 1.53, les tableaux implémentent le trait IntoIterator, qui permet d'itérer directement sur des tableaux par valeur sous la forme suivante :
| Code Rust : | Sélectionner tout |
1 2 3 4 | for i in [1, 2, 3] { .. } |
En effet, jusqu'à Rust 1.53, seules les références aux tableaux implémentent IntoIterator. Cela signifie que vous pouvez itérer sur &[1, 2, 3] et &mut [1, 2, 3], mais pas sur [1, 2, 3] directement. Selon l'équipe, il s'agit d'un problème de longue date, mais la solution n'est pas aussi simple qu'il paraît. L'ajout de l'implémentation du trait casserait le code existant. array.into_iter() compile déjà aujourd'hui parce qu'il appelle implicitement (&array).into_iter() en raison du fonctionnement de la syntaxe d'appel de méthode.
Lors de l'annonce de Rust 2021 en mai, elle a déclaré que l'ajout de l'implémentation du trait en changerait la signification. Habituellement, l'équipe qualifie ce type de rupture de "mineure" et acceptable. Mais dans ce cas, il y a trop de code qui serait cassé par cela. Selon elle, il a été suggéré à plusieurs reprises de n'implémenter IntoIterator que pour les tableaux en Rust 2021. Cependant, cela n'est tout simplement pas possible. Vous ne pouvez pas avoir une implémentation de trait existant dans une édition et pas dans une autre, puisque les éditions peuvent être mélangées.
Au lieu de cela, l'équipe a décidé d'ajouter l'implémentation de trait dans toutes les éditions (à partir de Rust 1.53), mais d'ajouter un petit hack pour éviter la rupture jusqu'à Rust 2021. Dans le code Rust 2015 et 2018, le compilateur résoudra toujours array.into_iter() en (&array).into_iter() comme avant, comme si l'implémentation du trait n'existait pas. Cela s'applique uniquement à la syntaxe d'appel de la méthode .into_iter(). Cela n'affecte pas les autres syntaxes telles que for e in [1, 2, 3], iter.zip([1, 2, 3]) ou IntoIterator::into_iter([1, 2, 3]).
Celles-ci commenceront à fonctionner dans toutes les éditions. Selon l'équipe, bien qu'il soit dommage que cela nécessite un petit hack pour éviter la casse, elle se dit heureuse de la façon dont cette solution maintient la différence entre les éditions à un minimum absolu. Comme le hack n'est présent que dans les anciennes éditions, il n'y a pas de complexité supplémentaire dans la nouvelle édition.
Les autres changements dans Rust 2021
- les motifs des macro-règles correspondent au niveau supérieur A|B ;
- la version 2 du résolveur de fonctionnalités Cargo est maintenant par défaut ;
- TryInto, TryFrom et FromIterator sont maintenant dans la portée par défaut ;
- les macros de panique attendent désormais des chaînes de format ;
- la syntaxe est réservée à ident#, ident"..." et ident'...' ;
- le code qui déclenche bare_trait_objects et ellipsis_inclusive_range_patterns donne désormais une erreur.
Les API stabilisées dans Rust 2021
Les méthodes et implémentations de traits suivantes ont été stabilisées :
- std::os::unix::fs::chroot ;
- UnsafeCell::raw_get ;
- BufWriter::into_parts ;
- core::panic::{UnwindSafe, RefUnwindSafe, AssertUnwindSafe} ;
- (auparavant uniquement dans std) ;
- Vec::shrink_to ;
- String::shrink_to ;
- OsString::shrink_to ;
- PathBuf::shrink_to ;
- BinaryHeap::shrink_to ;
- VecDeque::shrink_to ;
- HashMap::shrink_to ;
- HashSet::shrink_to.
Les fonctions suivantes, auparavant stables, sont maintenant constantes :
- std::mem::transmute ;
- [T]::first ;
- [T]::split_first ;
- [T]::last ;
- [T]::split_last.
Source : Rust 1.56 et Rust 2021
Et vous ?
Quel est votre avis sur le sujet ? Que pensez-vous de l'édition 2021 de Rust ? Rust est-il en bonne voie pour remplacer le langage C en tant que langage de programmation système ?Voir aussi
Feuille de route de Rust pour 2021 : l'équipe souhaite étendre la communauté du langage et pourrait travailler sur une éventuelle édition de Rust 2021 L'équipe de développement de Rust présente son plan pour Rust 2021 qui correspond à la troisième édition du langage, avec une amélioration significative à la façon dont Rust se comporte en pratique Rust 1.51 est disponible avec Resolver, une nouvelle fonctionnalité pour Cargo et l'implémentation MVP des const generics Rust 1.50.0 est disponible et s'accompagne de l'indexation de tableau générique Const, ainsi que des affectations sécurisées aux champs d'union ManuallyDrop<T>