Rust 1.17 est désormais disponible en version stable,et apporte, avec elle, de nombreuses améliorations
Ce 27 avril, l'équipe Rust a annoncé la sortie de la version 1.17 de Rust avec son lot de (bonnes !) surprises.
Avant de vous pencher sur les fonctionnalités de cette toute dernière version stable, n'oubliez pas que rustup vous permet d'installer cette dernière simplement (si vous ne disposez pas de rustup sur votre poste, n'hésitez pas à le télécharger).
| Code bash : | Sélectionner tout |
rustup update stable
Quoi de neuf dans la 1.17.0 ?
Cette version est principalement axée sur la souplesse de la syntaxe, les raccourcis et l'intelligibilité des erreurs.
Lifetime des constantes
Avant la 1.17.0, les références constantes devaient être annotées manuellement de la durée de vie 'static, sans quoi le compilateur risquait de vous renvoyer une erreur.
| Code Rust : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 | struct Foo; const BAR: &'static Foo = &Foo; // ou pour reprendre les exemples du billet const NAME: &'static str = "Ferris"; static NAME: &'static str = "Ferris"; // L'annotation commence à devenir relativement lourde const NAMES: &'static [&'static str; 2] = &["Ferris", "Bors"]; |
Pour remédier à cela, la nouvelle version propose de ne plus préciser cette durée de vie dans le type, mais de laisser le compilateur le faire à notre place (puisque, quoi qu'il arrive, une constante devrait avoir une durée de vie équivalente à celle de l'exécution du programme), allégeant drastiquement les annotations.
| Code Rust : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 | struct Foo; const BAR: &Foo = &Foo; // ou pour reprendre les exemples du billet const NAME: &str = "Ferris"; static NAME: &str = "Ferris"; // L'annotation commence à devenir relativement lourde const NAMES: &[&str; 2] = &["Ferris", "Bors"]; |
Code MIR de la constante BAR:
| Code Rust : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 | const BAR: &'static Foo = { // le compilateur ajoute bien la lifetime let mut _0: &'static Foo; // return pointer let mut _1: &'static Foo; let mut _2: Foo; bb0: { _2 = Foo::{{constructor}}; // scope 0 at <anon>:2:20: 2:23 _1 = &_2; // scope 0 at <anon>:2:19: 2:23 _0 = &(*_1); // scope 0 at <anon>:2:19: 2:23 return; // scope 0 at <anon>:2:1: 2:24 } } |
Assignation des champs raccourcie
Précédemment, les assignations effectuées sur les champs d'un objet lors de sa construction se faisaient de cette manière :
| Code Rust : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | struct Foo{ x: f64, y: f64, z: f64, } fn main() -> (){ let x = 10f64; let y = 15f64; let z = 20f64; let bar = Foo{ x: x, y: y, z: z, }; } |
Vous pouvez désormais omettre x:, y: et z:.
| Code Rust : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | struct Foo { x: f64, y: f64, z: f64, } fn main() { let bar = Foo { x, y, z }; // l'ordre importe peu, exemple: let bar = Foo { z, x, y }; println!("x:{0},y:{1},z:{2}", bar.x, bar.y, bar.z); // affiche: x:10,y:15,z:20 } |
Dans le billet, l'équipe Rust explique que ce raccourci est inspiré de celui proposé par l'ECMAScript 6.
L'opérateur +
En tant que débutant, il pourrait être aisé de croire qu'une concaténation entre deux primitifs &str s'effectue avec l'opérateur +, ce qui n'est bien entendu pas le cas. Pour épauler ces nouveaux utilisateurs, le message d'erreur a été réécrit.
(Exemple tiré du billet)
| Code Rust : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | // code "foo" + "bar" // Ancien message d'erreur error[E0369]: binary operation `+` cannot be applied to type `&'static str` --> <anon>:2:5 | 2 | "foo" + "bar" | ^^^^^ | note: an implementation of `std::ops::Add` might be missing for `&'static str` --> <anon>:2:5 | 2 | "foo" + "bar" | ^^^^^ // Nouveau message d'erreur error[E0369]: binary operation `+` cannot be applied to type `&'static str` --> <anon>:2:5 | 2 | "foo" + "bar" | ^^^^^ | = note: `+` can't be used to concatenate two `&str` strings help: to_owned() can be used to create an owned `String` from a string reference. String concatenation appends the string on the right to the string on the left and may require reallocation. This requires ownership of the string on the left. | "foo".to_owned() + "bar" |
À propos de Cargo
Comme vous le savez, Cargo est le système de build natif du langage Rust. Pour cette version, il a également subi quelques modifications.
Jusqu'ici, lorsque nous avions besoin de personnaliser le processus de compilation (pour compiler des sources non-Rust, par exemple), il était nécessaire de renseigner l'option build suivie du chemin du fichier chargé d'aller chercher les ressources désirées. Toutefois, une grande majorité des utilisateurs de cargo se contentent de créer le fichier build.rs à la racine du projet, ce qui rend (dans ce cas) l'option inutile. En réponse à cela, désormais, si aucun chemin n'est renseigné dans le manifest Cargo.toml, Cargo ira chercher le fichier à la racine du projet.
Note : vous pouvez toutefois annuler cette convention, si vous le souhaitez, en assignant build = false.
Deux autres flags ont également été ajoutés aux commandes check et run. Respectivement, l'une supporte le flag --all (i.e. qui permet de vérifier la syntaxe des sources, sans les compiler, de tous les packages se trouvant dans votre espace de travail), l'autre supporte le flag --package <arg1, arg2, argn> (i.e. qui permet d'empaqueter le binaire du (ou des) package que vous lui renseignerez).
Enfin, un nouveau paquet est disponible sur crates.io pour la rédaction de la documentation de vos projets : mdbook !
C'est, en quelque sorte, un équivalent à gitbook qui vous permet de générer un site en markdown en vous proposant divers outils tels que la commande test (qui vous permet de repérer les liens morts, les fichiers inutilisés), un gestionnaire de thèmes ou encore l'expression {{#playpen your_file.rs}} qui vous permet d'intégrer du code source (qui sera compilé par le playpen) à exécuter par l'utilisateur, dans votre documentation.
À propos de rustup
Dernière nouvelle, mais pas des moindres : rustup télécharge pour vous l'intégralité de la documentation officielle de Rust sur votre poste lorsque vous installez une nouvelle version du langage. Celui-ci embarquera le livre officiel de la version stable, le Rustonomicon et la documentation des versions encore instables du langage.
Pour y accéder depuis votre terminal, il vous suffit de taper rustup doc.
En vous souhaitant une bonne lecture !
Notez toutefois que d'autres fonctionnalités ont été ajoutées dans cette version, n'hésitez pas à vous rendre sur le billet relatif à l'annonce.
Source : Rust Core Team blog
Et vous ?
Quelle(s) fonctionnalité(s) souhaiteriez-vous voir apparaître dans les prochaines versions ?Voir aussi
Mozilla annonce la disponibilité de Rust 1.16, qui s'accompagne de la sous-commande cargo check Rust 1.13.0 est disponible, avec des optimisations du compilateur et un nouvel opérateur « ? » pour mieux gérer les exceptions FAQ sur la programmation en langage Rust 
Envoyé par mh-cbon
