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.46.0 est disponible et s'accompagne de plusieurs nouveautés dans const fn
Ainsi que de deux nouvelles API dans la bibliothèque standard

Le , par Stéphane le calme

198PARTAGES

11  0 
L'équipe Rust a annoncé la disponibilité de Rust 1.46.0. Cette version s'accompagne de nombreuses nouveautés dans const fn, deux nouvelles API de bibliothèque standard et une fonctionnalité utile pour les auteurs de bibliothèques.

Améliorations au niveau de const fn

Il existe plusieurs fonctionnalités de langage de base que vous pouvez désormais utiliser dans const fn telles que :
  • if, if let et match ;
  • while, while let et loop ;
  • ainsi que les opérateurs && et ||.

Pour mémoire, les slices sont similaires aux tableaux, à l'exception de leur taille qui n'est pas connue à la compilation. Une slice est un objet composé de deux « mots », le premier étant un pointeur vers la ressource initiale et le second étant la taille de la slice. La taille en mémoire de la slice est déterminée par l'architecture du processeur (e.g. 64 bits pour une architecture x86-64). Les slices peuvent être utilisées pour isoler une partie d'un tableau et héritent de la signature de ce dernier &[T].

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
30
31
32
33
34
35
36
37
38
use std::mem;
 
 
// Cette fonction emprunte une slice.
fn analyze_slice(slice: &[i32]) {
    println!("first element of the slice: {}", slice[0]);
    println!("the slice has {} elements", slice.len());
}
 
fn main() {
    // Tableau dont la taille est connue à la compilation (le type peut être omis).
    let xs: [i32; 5] = [1, 2, 3, 4, 5];
 
    // Tous les éléments peuvent être initialisés à la même valeur.
    let ys: [i32; 500] = [0; 500];
 
    // L'indexation débute à 0.
    println!("first element of the array: {}", xs[0]);
    println!("second element of the array: {}", xs[1]);
 
    // `len` renvoie la taille du tableau.
    println!("array size: {}", xs.len());
 
    // Les tableaux sont alloués dans la pile.
    println!("array occupies {} bytes", mem::size_of_val(&xs));
 
    // Les tableaux peuvent être automatiquement empruntés en tant que 
    // slice.
    println!("borrow the whole array as a slice");
    analyze_slice(&xs);
 
    // Les slices peuvent pointer sur une partie bien précise d'un tableau.
    println!("borrow a section of the array as a slice");
    analyze_slice(&ys[1 .. 4]);
 
    // Erreur! Le dépassement de tampon fait planter le programme.
    // println!("{}", xs[5]);
}

Dans cette version, vous serez désormais capable de forcer et de convertir en slice dans les const fn.

Code Rust : Sélectionner tout
1
2
3
4
5
6
const fn foo() {
  let x = [1, 2, 3, 4, 5];
 
  // conversion du tableau en slice
  let y: &[_] = &x;
}
Bien que ces fonctionnalités ne semblent pas nouvelles, étant donné que vous pouvez toutes les utiliser en dehors de const fn, elles ajoutent beaucoup de puissance de calcul au moment de la compilation! Par exemple, le crate const-sha1 peut vous permettre de calculer les hachages SHA-1 au moment de la compilation. Cela a conduit à une amélioration des performances de 40x dans les liaisons WinRT de Microsoft pour Rust.


#[track_caller]

En mars, la sortie de Rust 1.42 a introduit de meilleurs messages d'erreur lorsqu'un unwrap et les fonctions associées entraient en panique (situation obtenue lorsque les programmes Rust atteignent un état où une erreur critique est survenue). À l'époque, l'équipe a mentionné que la façon dont cela a été mis en œuvre n'était pas encore stable. Rust 1.46 apporte une stabilité à cette fonctionnalité.

Cet attribut s'appelle #[track_caller], qui a été proposé à l'origine dans la RFC 2091 en juillet 2017! Si vous écrivez une fonction comme unwrap qui pourrait entrer en panique, vous pouvez mettre cette annotation sur vos fonctions, et le formateur panique par défaut utilisera son appelant comme emplacement dans son message d'erreur. Par exemple, voici unwrap précédemment :

Code Rust : Sélectionner tout
1
2
3
4
5
6
pub fn unwrap(self) -> T {
    match self {
        Some(val) => val,
        None => panic!("called `Option::unwrap()` on a `None` value"),
    }
}

Cela ressemble maintenant à ceci :

Code Rust : Sélectionner tout
1
2
3
4
5
6
7
#[track_caller]
pub fn unwrap(self) -> T {
    match self {
        Some(val) => val,
        None => panic!("called `Option::unwrap()` on a `None` value"),
    }
}

Si vous implémentez vous-même un hook panic, vous pouvez utiliser la méthode caller sur std::panic::Location pour accéder à ces informations.

Changements au niveau de la bibliothèque

Deux API sont disponibles en version stable avec cette version, il s'agit de :
  • Option::zip
  • vec::Drain::as_slice

Autres changements

Il y a d'autres changements dans la version Rust 1.46.0 qui concernent par exemple Cargo. Une note de compatibilité a également été fournie.

Source : note de version

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