La version 1.25 de Rust est désormais disponible,

Et apporte avec elle stabilisation et réorganisation dans l'écosystème du langage

Le 11 avril 2018 à 20:17, par Songbird

91PARTAGES

Comme l'équipe Rust a pu le communiquer à travers le post original, cette version n'apporte pas d'ajouts majeurs, mais vient plutôt consolider, et améliorer, ce qui a été précédemment implémenté.

Mise à niveau de LLVM

Les outils du compilateur de Rust fonctionnaient, jusqu'ici, avec LLVM 4. Cette version supportait déjà les microcontrôleurs AVR, mais disposait de nombreux bogues, un passage à LLVM 6 rectifie donc le tir pour Rust.

Ajout: imports imbriqués

Jusqu'à présent, lorsque nous souhaitons importer plusieurs composants provenant d'un même module, il est courant d'écrire ceci:

Code Rust :

Sélectionner tout

use std::path::{Path, PathBuf};

Ou encore, lorsque nous souhaitons importer plusieurs composants provenant de modules différents:

Code Rust :

Sélectionner tout

1
2
3
4
  
use std::fs::File; 
use std::io::Read; 
use std::path::{Path, PathBuf};

Désormais, ça ne sera plus nécessaire. La 1.25 permet l'importation imbriquée lorsque plusieurs sous-modules partagent un même module parent/racine.

(Exemple provenant du post original)

Code Rust :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
// Exemple "inline" 
use std::{fs::File, io::Read, path::{Path, PathBuf}}; 
  
// Équivalent à la ligne du dessus. 
use std::{ 
    fs::File, 
    io::Read, 
    path::{ 
        Path, 
        PathBuf 
    } 
};

Documentation et Markdown

Du côté de la documentation, le livre Rust by Example est officiellement publié sur doc.rust-lang.org. En conséquence, vous pourrez obtenir une version offline du livre, comme toutes les autres ressources officielles.

Pour ce qui est de rustdoc, l'équipe Rust annonce que les dernières lignes de code écrites en C se trouvant encore dans l'outil ne sont plus, tandis qu'en parallèle ce dernier s'accorde également avec les spécifications CommonMark pour le parsing du markdown.

Ajout: gestion de l'alignement mémoire

La 1.18 apportait une solution automatique pour optimiser les accès en mémoire mais qui, toutefois, pouvait avoir un coût en ressources plus ou moins important en fonction des besoins. La 1.25 permet de configurer le coût de la compensation en utilisant l'attribut #[repr(align(x))].

(Exemple provenant du post original)

Code Rust :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
struct Number(i32); 
  
assert_eq!(std::mem::align_of::<Number>(), 4); 
assert_eq!(std::mem::size_of::<Number>(), 4); 
  
#[repr(align(16))] 
struct Align16(i32); 
  
assert_eq!(std::mem::align_of::<Align16>(), 16); 
assert_eq!(std::mem::size_of::<Align16>(), 16);

Stabilisation de la std

Concernant la bibliothèque standard, une nouvelle structure, dédiée à la gestion des pointeurs, a été ajoutée : std::ptr::NonNull<T>. Elle permet la gestion de pointeurs mutables tout en offrant la garantie que le pointeur soumis n'est jamais nul.
Par ailleurs, son utilisation est vivement recommandée lorsque du code source Rust communique avec du code étranger (ou "unsafe").

Ajoutons à cela que les méthodes from_secs et from_millis ont vu leur signature changer pour pouvoir être utilisée lors de la définition de constantes.

Code Rust :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
// Exemple d'utilisation pour les deux fonctionnalités présentées. 
  
use std::{ 
    time::Duration, 
    ptr::NonNull 
}; 
  
const A_DURATION: Duration = Duration::from_secs(20); 
  
fn main() { 
    let mutable_integer: NonNull<u8> = NonNull::new(0 as *mut u8).expect("The pointer is null."); 
}

Du nouveau pour Cargo

Nous terminerons sur les petites modifications de comportement apportées aux commandes cargo new et cargo doc.

Pour la première, cargo new générera, désormais, un projet exécutable par défaut. Ajoutons à cela que la commande ne renommera plus les projets préfixés par rust- et/ou suffixés par rs-, après un retour de la communauté sur le sujet.

Pour la seconde, cargo doc bénéficie d'un gain de performance non négligeable. Au lieu de recompiler systématiquement les sources, la commande ne collectera, désormais, plus que les métadonnées nécessaires à la génération de la documentation, réduisant ainsi le temps de traitement.

Source : Annonce officielle

Et vous ?