Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

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

Le , par Songbird

23PARTAGES

8  0 
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 (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

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de Songbird
Expert confirmé https://www.developpez.com
Le 10/06/2017 à 18:41


Je ne doutes pas que je finirais par en faire,
mais aujourd'hui à cet instant, la chose n'est pas évidente pour moi
et je préfère encore me tourner vers d'autres langages
partageant certains points commun avec celui ci.
Qu'est-ce qui te paraît peu évident ? Tes questions et remarques sont les bienvenues.

Concernant la syntaxe, c'est précisément ce qui me donne envie d'étudier Rust (si l'on ne parle que d'elle), car la syntaxe me semble moins... éparpillée que le C++. Cela reste très personnel, bien entendu.
D'ailleurs, si quelque chose te rebute dans la syntaxe, des ressources existent pour expliquer littéralement ce que signifie telle ou telle expression.

Très bonne journée !
2  0 
Avatar de mh-cbon
Membre extrêmement actif https://www.developpez.com
Le 10/06/2017 à 12:08
Rust c'est tout de même plusieurs choses, amha.

Un langage pour répondre aux problèmes de ces prédécesseurs.
Un toolset autour du langage pour vivre avec.
Un esprit définitivement progressiste et tourné vers l'avenir.

De cet ensemble, je suis très satisfait,
c'est un changement appréciable car il est plus proche des utilisateurs,
en comparaison, pendant longtemps les avancées que l'on pouvait lire à propos des langages
concernaient des questions très théorique de la théorie des langages (preuves formelles etc)
qui finalement aboutissaient à peu de changement concret/applicable pour l'utilisateur final lambda.

J'apprécie beaucoup cela, pour autant est ce que j'aime ce langage,
bein pas trop en fait,
comme tout le monde, j'aime bien sa théorie et sa mise en pratique,
mmmmmeeeeehhhhhh
la syntaxe est bien trop complexe pour mon goût personnel.

Je ne doutes pas que je finirais par en faire,
mais aujourd'hui à cet instant, la chose n'est pas évidente pour moi
et je préfère encore me tourner vers d'autres langages
partageant certains points commun avec celui ci.
1  0 
Avatar de imperio
Membre chevronné https://www.developpez.com
Le 10/06/2017 à 13:56
la syntaxe est bien trop complexe pour mon goût personnel.
Ah ? Voilà qui est intéressant ! Venant des langages C/C++, j'ai trouvé la syntaxe de rust nettement plus simple. De quel(s) langage(s) viens-tu du coup ?
1  0 
Avatar de mothsART
Membre régulier https://www.developpez.com
Le 11/06/2017 à 14:13
Mh-cbon : ton approche top => bottom est bonne : beaucoup ne font pas l'effort et du coup progresse peu à mon sens.
Le passage à un typage fort est douloureux mais au final nécessaire car le gain est juste énorme : tu évites une paire de bug à l’exécution, le code est plus cohérent, t'as de meilleurs perfs etc.

Tu mets C et C++ dans le panier des vieux langages mais tu remarqueras que Go ne les remplace pas vraiment car il utilise un Garbage collector et une VM.
Pour moi, Go est un Java bis avec une syntaxe minimaliste, des gros avantages sur la programmation concurrente et des temps de compilation plus court.
Bref, rien de bien novateur à mon sens.

La réalité est que C et C++ sont pour l'instant encore indétrônable dans tous les domaines ou les perfs et la gestion de la mémoire sont critiques.
Rust étant plus ambitieux et par conséquent plus complexe est un réel candidat pour les remplacer.

Je dirais, pour ma part que le cap à passer pour Rust n'était pas vraiment la syntaxe (que je trouve élégante et intuitive) mais plus le borrowing. (et dans une moindre mesure les macros et closures)

Mais, comme tous les langages, il a des zones implicites qui nécessite apprentissage.
Ton exemple et ton incompréhension proviennent de là :

* la variable "f" et "let mut f" : f est dans un premier temps immutable : si le match réussi (passe par le Ok), cette variable est écrasé par le résultat et est converti en une variable mutable.
* le type Result est un peu particulier : il attend soit un objet succès ("Ok" avec le résultat (ici typé en String car on désire récupérer le contenu du fichier mais ça pourrais être n'importe quoi d'autre dans un autre contexte) ou un objet d'échec ("Err".
* le premier match (qui vérifie l'accès en lecture du fichier) a un retour explicite qui précise que si il détecte une erreur, il sort directement de la fonction (et par conséquent la variable mutable f n'est pas alimenté, la variable s n'est pas créé et le dernier match non executé.
* let permet de déclarer une variable, je ne vois pas trop ce qui te choques. (tu remplaces "var" par "let" dans ton passage de Go à Rust ou de NodeJS à Rust)
* en rust si la dernière ligne d'une fonction ne se termine pas par ";", on retourne implicitement le résultat.
C'est ce qui se passe dans le dernier match.
* s n'est pas déclaré 2 fois, elle est passé par référence dans la fonction "read_to_string".
* read_username_from_file renvoi une valeur qui peut parfaitement être mutable ou non selon la déclaration de ta variable de récupération :
Code : Sélectionner tout
1
2
3
4
let username_immutable = read_username_from_file();
// ou
let mut username_mutable = read_username_from_file();
1  0 
Avatar de Uther
Expert éminent sénior https://www.developpez.com
Le 12/06/2017 à 13:18
Citation Envoyé par mh-cbon  Voir le message
Je ne vois pas où est construit le retour Result<...>.

Result est un cas particulier vu que comme c'est un élément central du langage, ses variant OK et Err sont inclus dans le prélude, ce qui fait que l'on peut les utiliser directement. Comme le type Result est utilisé partout, n'importe qui avec un minimum d'expérience dans le langage reconnais ça du premier abord.

Cependant, si tu tient à ce que ce soit clair que Ok et Err sont des variants du type énuméré Result, tu peux faire :
Code Rust : Sélectionner tout
1
2
3
4
    let mut f = match f { 
        Result::Ok(file) => file, 
        Result::Err(e) => return Result::Err(e), 
    };
1  0 
Avatar de Songbird
Expert confirmé https://www.developpez.com
Le 12/06/2017 à 18:09


Tout comme les variantes de l'enum Option: Some(T) et None sont parfaitement comprises par le compilateur.

Sans expliciter la provenance des variantes ça donne:

Code Rust : Sélectionner tout
1
2
3
4
5
6
7
8
fn main() { 
    let foo = Some("Hello there!".to_owned()); 
    let bar = match foo{ 
        Some(content) => content, 
        None => "Nothing, here.".to_owned(), 
    }; 
    println!("bar={}", &bar); 
}

Ce sont de petites subtilités, mais vraiment rien d'insurmontable. Ce ne sont pas des ressources "magiques", juste des raccourcis.
1  0 
Avatar de tralloc
Membre actif https://www.developpez.com
Le 15/06/2017 à 9:19
@mh-cbon
Eh bien moi c'est la deuxième fois que je me penche sur ce language.la première fois je l'ai trouvé trop complexe moi aussi.
Rien à voir avec les typages forts parce que je fais du JEE du C. Ni les typages faibles, car je ne suis pas trop mauvais en python.
Eh bien pour une deuxième fois, je commence à l'apprécier, et je crois qu'il vaut vraiment le coup.

La syntaxe est une chose, lorsqu'on a commencé à la comprendre il faut ensuite l'adopter. Une fois ce cap passé on peut profiter de sa richesse.
1  0 
Avatar de Kennel sébastien
Membre averti https://www.developpez.com
Le 15/06/2017 à 10:19
Bonjour tralloc,

C'est super de chercher à aider les autres :-).

Je voulais juste me permettre de te signaler un point :-p :
Tu as écrit « Ni les typages faibles, car je ne suis pas trop mauvais en python », or Python a un typage fort, en effet tu confonds typage statique et dynamique mais les trois langages ont des typages fort.

Des langages qui auraient des typages faibles sont par exemple : PHP, Javascript ou Ring.

Code : Sélectionner tout
print(5 + "5")
Ne travaille pas en Python, mais sous Ring avec :
Code : Sélectionner tout
See 5 + "5"
Tu obtiens le résultat 10 !

Rust a en fait un typage qui est inféré comme Go, Crystal, Swift…, c'est-à-dire que tu peux le rendre statique ou le laisser chercher le type pour toi alors que tu pourrais pas le faire en Python, en Python c'est lui qui cherche pour toi, il n'y a pas de déclaration de type.

Enfin pour ceux qui trouvent trop difficile Rust, peut-être vous tournez sur Go et revenir après sur Rust…
1  0 
Avatar de tralloc
Membre actif https://www.developpez.com
Le 15/06/2017 à 9:28
Je peux te filer un lien avec des exos pour pratiquer :
http://exercism.io/
mais avant il faut se taper de la doc, ce n'est pas un language simple.
Voici un tutoriel en français sur ce site.
http://guillaume-gomez.developpez.co...re-bases-rust/

Sinon il y a la doc officielle !
0  0 
Avatar de tralloc
Membre actif https://www.developpez.com
Le 15/06/2017 à 10:41
Oui je me suis trompé dans le mot que j'ai employé dsl
Je ne le referai plus promis
0  0 
Contacter le responsable de la rubrique Accueil

Partenaire : Hébergement Web