Newsletter Developpez.com

Inscrivez-vous gratuitement au Club pour recevoir
la newsletter hebdomadaire des développeurs et IT pro

Rust 1.17 est désormais disponible en version stable,
Et intègre de nombreuses améliorations

Le , par Songbird_, Rédacteur
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


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :
Offres d'emploi IT
Architecte / concepteur électronique numérique H/F
Safran - Ile de France - Éragny (95610)
Expert Technico Fonctionnel Sharepoint H/F
Safran - Ile de France - Corbeil (91)
Ingénieur produit (Landing gear) H/F
Safran - Ile de France - MASSY Hussenot

Voir plus d'offres Voir la carte des offres IT
Contacter le responsable de la rubrique Accueil