La version stable de Rust 1.26 est maintenant disponible,

Et est probablement la version la plus riche en termes de fonctionnalités depuis Rust 1.0

Le 2018-05-12 01:50:28, par Blondelle Mélina, Chroniqueuse Actualités

L'équipe de Rust a annoncé la sortie de la version 1.26.0 du langage de programmation Rust. Pour rappel, ce dernier est un langage de programmation système ultra-rapide, qui prévient les erreurs de segmentation et garantit la sûreté entre threads. Pendant près de 18 mois, Carol, Steve et d'autres ont travaillé sur la réécriture complète de « The Rust Programming Language ». Depuis la version 1.0 du langage de programmation, la version 1.26 est la version stable la plus riche en fonctionnalités d'après les développeurs de Rust. Les autres ayant reçu que quelques changements mineurs.

Si vous avez une version antérieure de Rust installée via rustup, pour obtenir Rust 1.26.0, vous pouvez exécuter cette commande : $ rustup update stable. Mais, si vous ne l'avez pas encore installé, vous pouvez l'obtenir ici.

Qu'est-ce qu'il y a de nouveau avec la version 1.26.0 du langage Rust ?

L'ajout de la fonctionnalité impl Trait qui a longtemps été réclamée par la communauté des développeurs Rust, car elle fournit une fonctionnalité connue sous le nom de « types existentiels ».

Code rust :

fn foo () -> impl Trait { // ... }

Pour rendre la syntaxe un peu plus symétrique, vous pouvez utiliser impl Trait en position d'argument.

Code rust :

1
2
3
4
5
  
// before  
fn foo < T : Trait > ( x : T ) {  
// after  
fn foo ( x : impl Trait ) {

L'équipe Rust a aussi apporté des améliorations à la fonctionnalité match. Elle était au préalable utilisée comme ci-dessous :

Code rust :

1
2
3
4
5
6
7
  
fn hello(arg: &Option<String>) { 
    match arg { 
        &Some(name) => println!("Hello {}!", name), 
        &None => println!("I don't know who you are."), 
    } 
}

mais ne marchait pas sur Rust 1.25.0. Le message d'erreur ci-après apparaissait :

Code rust :

1
2
3
4
5
6
7
8
9
  
error[E0507]: cannot move out of borrowed content 
 --> src/main.rs:6:9 
  | 
6 |         &Some(name) => println!("Hello {}!", name), 
  |         ^^^^^^----^ 
  |         |     | 
  |         |     hint: to prevent move, use `ref name` or `ref mut name` 
  |         cannot move out of borrowed content

Ils ont apporté des améliorations en ajoutant ref devant name pour obtenir une référence à l'intérieur de l'option.

Code rust :

1
2
3
4
5
6
7
  
fn hello(arg: &Option<String>) { 
    match arg { 
        &Some(ref name) => println!("Hello {}!", name), 
        &None => println!("I don't know who you are."), 
    } 
}

Néanmoins, pour la version 1.26 de Rust, la fonctionnalité match sera maintenant utilisée comme l'indique le code suivant :

Code rust :

match arg { Some ( name ) => println! ( "Hello {}!" , name ),

Le code sera sans & et ref, mais compilera et fera exactement ce que nous attendons. Le compilateur référencera ou dé-référencera automatiquement dans les instructions de match.

Dans Rust 1.26, il sera maintenant possible de déclarer la fonction main qui renvoie Result :

Code rust :

1
2
3
4
5
6
  
use std::fs::File; 
fn main() -> Result<(), std::io::Error> { 
    let f = File::open("bar.txt")?; 
    Ok(()) 
}

Si la fonction main renvoie une erreur, elle se termine avec un code d'erreur et imprime une représentation de débogage de l'erreur.

Dans Rust 1.26, vous pouvez maintenant créer une plage inclusive, comme ceci :

Code rust :

1
2
3
4
  
for i in 1. .= 3 {  
    println! ( "i: {}" , i );  
}

Cela va imprimer i: 1 et ensuite i: 2 comme avant, mais aussi i: 3 ; les trois sont inclus dans la gamme. Les plages inclusives sont particulièrement utiles si nous souhaitons parcourir toutes les valeurs possibles dans une plage.
Dans Rust 1.0, nous avions été en mesure de créer des gammes exclusives avec . . comme ceci :

Code rust :

1
2
3
4
  
for i in 1. .= 3 {  
    println! ( "i: {}" , i );  
}

Qui imprimait i: 1 puis i: 2.

L'équipe du langage de programmation Rust dit avoir également stabilisé la bibliothèque fs::read_to_string, une commodité sur File::open et io::Read::read_to_string pour lire facilement un fichier entier en mémoire à la fois :

Code rust :

1
2
3
4
  
use std :: fs;  
use std :: net :: SocketAddr;  
let foo : SocketAddr = fs :: read_to_string ( "address.txt" )?.parse ()?;

Vous pouvez maintenant mettre en forme des nombres au format hexadécimal avec le formatage Debug :

Code rust :

assert! ( format! ( "{:02x?}" , b "Foo\0" ) == "[46, 6f, 6f, 00]" )

Les virgules de fin sont maintenant supportées par toutes les macros de la bibliothèque standard.

Source : Rust

Et vous ?

Qu'en pensez-vous ?
Quelle nouveauté appréciez-vous le plus ?

Voir aussi :

La version 1.25 de Rust est désormais disponible, et apporte avec elle stabilisation et réorganisation dans l'écosystème du langage

Rust : apprendre à encoder et décoder du TOML avec la bibliothèque toml-rs, un tutoriel d'Anthony Defranceschi

La version stable de Rust 1.24 est disponible, avec la compilation incrémentielle par défaut pour améliorer le temps de compilation des projets

Discussion forum

6 commentaires

mothsART
Membre régulier

Est-ce possible de mettre des retours à la ligne sur les exemples de match ?
à la lecture c'est bof (et non conventionnel) et en plus ça nécessite de scroller horizontalement.

le 12/05/2018 à 9:49
Malick
Community Manager

Salut,

Envoyé par mothsART

Est-ce possible de mettre des retours à la ligne sur les exemples de match ?

C'est fait.

le 12/05/2018 à 19:48
Songbird
Membre expert

Bonjour,

Est-ce possible de mettre des retours à la ligne sur les exemples de match ?
à la lecture c'est bof (et non conventionnel) et en plus ça nécessite de scroller horizontalement.

J'ai formaté tous les exemples qui en avait besoin. Merci à toi.

le 12/05/2018 à 20:22