L'équipe Rust est heureuse d'annoncer une nouvelle version de Rust, 1.61.0. Rust est un langage de programmation qui permet à chacun de construire des logiciels fiables et efficaces.

Si vous avez une version précédente de Rust installée via rustup, vous pouvez obtenir la 1.61.0 avec :

rustup update stable

Si vous ne l'avez pas encore, vous pouvez obtenir rustupà partir de la page appropriée de notre site web, et consulter les notes de publications de la version 1.61.0 sur GitHub.

Si vous souhaitez nous aider en testant les futures versions, vous pouvez envisager de mettre à jour localement pour utiliser le canal beta (rustup default beta) ou le canal nightly (rustup default nightly). Signalez tous les bugs que vous pourriez rencontrer s’il-vous-plaît !

Contenu de la version stable 1.61.0

Codes de sortie personnalisés de main

À l'origine, les fonctions main ne pouvaient renvoyer que le type unitaire () (implicitement ou explicitement), indiquant toujours le succès dans le statut de sortie, et si vous vouliez autre chose, vous deviez appeler process::exit(code). À partir de Rust 1.26, main peut retourner Result, où Ok se traduit par un EXIT_SUCCESS  de C et Err à EXIT_FAILURE (avec également une impression de débogage de l'erreur). Sous le capot, ces types de retour alternatifs ont été unifiés par un trait Termination instable.

Dans cette version, le trait Termination est enfin stable, ainsi qu'un type ExitCode plus général qui englobe les types de retour spécifiques à la plateforme. Ce type possède des constantes SUCCESS et FAILURE, et implémente également From<u8> pour des valeurs plus arbitraires. Le trait Termination peut également être implémenté pour vos propres types, vous permettant de personnaliser tout type de rapport avant de le convertir de ExitCode.

Par exemple, voici une façon sûre d'écrire les codes de sortie pour un script git bisect run :

use std::process::{ExitCode, Termination};

#[repr(u8)]
pub enum GitBisectResult {
    Good = 0,
    Bad = 1,
    Skip = 125,
    Abort = 255,
}

impl Termination for GitBisectResult {
    fn report(self) -> ExitCode {
        // Maybe print a message here
        ExitCode::from(self as u8)
    }
}

fn main() -> GitBisectResult {
    std::panic::catch_unwind(|| {
        todo!("test the commit")
    }).unwrap_or(GitBisectResult::Abort)
}

Plus de possibilités pour const fn

Plusieurs fonctionnalités incrémentales ont été stabilisées dans cette version pour permettre plus de fonctionnalités dans les fonctions de const :

• Manipulation de base des pointeurs fn: Vous pouvez maintenant créer, passer et caster des pointeurs de fonction dans une const fn. Par exemple, cela pourrait être utile pour construire des tables de fonctions à la compilation pour un interpréteur. Cependant, il n'est pas toujours pas permis d’appeler les pointeurs fn.

• Limites de traits : Vous pouvez maintenant écrire des limites de traits sur les paramètres génériques des const fn, comme T: Copy, alors qu'auparavant seul Sized était autorisé.

• Types dyn Trait : De la même manière, const fn peut maintenant traiter les objets dyn Trait.

• Types impl Trait: Les arguments et les valeurs de retour de const fn peuvent maintenant être des types impl Trait opaques.

Notez que les caractéristiques des traits ne supportent pas encore l'appel de méthodes de ces traits dans un const fn.

Consultez la section Constant Evaluationdu livre de référence pour en savoir plus sur les capacités actuelles des contextes const, les capacités futures peuvent être suivies dans rust#57563.

Handles statiques pour les verrous de stdio

Les trois flux I/O standards — Stdin, Stdout, et Stderr — ont chacun un  lock(&self) pour permettre plus de contrôle sur la synchronisation des lectures et des écritures. Cependant, ils renvoient des gardes de verrou avec une durée de vie empruntée à &self de sorte qu'ils sont limités à la portée du handle original. Il a été déterminé que c'était une limitation inutile, puisque les verrous sous-jacents étaient en fait dans un stockage 'static, déconnectée du handle.

Par exemple, une erreur fréquente consistait à essayer d'obtenir un handle et de le verrouiller dans une seule instruction :

// error[E0716]: temporary value dropped while borrowed
let out = std::io::stdout().lock();
//        ^^^^^^^^^^^^^^^^^       - temporary value is freed at the end of this statement
//        |
//        creates a temporary which is freed while still in use

Maintenant, le verrou est 'static,  et n'emprunte pas de valeur temporaire, donc cela fonctionne !

APIs stabilisés

Les méthodes et les implémentations de traits suivantes sont maintenant stabilisées :

• Pin::static_mut
• Pin::static_ref
• Vec::retain_mut
• VecDeque::retain_mut
• Write pour Cursor<[u8; N]>
• std::os::unix::net::SocketAddr::from_pathname
• std::process::ExitCode
• std::process::Termination
• std::thread::JoinHandle::is_finished

Les fonctions suivantes, auparavant stables, sont désormais const:

• <*const T>::offset et <*mut T>::offset
• <*const T>::wrapping_offset et <*mut T>::wrapping_offset
• <*const T>::add et <*mut T>::add
• <*const T>::sub et <*mut T>::sub
• <*const T>::wrapping_add et <*mut T>::wrapping_add
• <*const T>::wrapping_sub et <*mut T>::wrapping_sub
• <[T]>::as_mut_ptr
• <[T]>::as_ptr_range
• <[T]>::as_mut_ptr_range

Autres changements

Il y a d'autres changements dans la version 1.61.0 de Rust. Découvrez ce qui a changé dans Rust, Cargo, et Clippy.

Dans une prochaine version, nous prévoyons d'augmenter les exigences de base pour le noyau Linux à la version 3.2, et pour la glibc à la version 2.17. Nous aimerions recevoir vos commentaires dans le cadre de rust#95026.

Contributeurs à la version 1.61.0

De nombreuses personnes se sont réunies pour créer Rust 1.61.0. Nous n'aurions pas pu le faire sans vous tous. Merci !