L'équipe Rust a annoncé la disponibilité de Rust 1.63, elle apporte un code Codes exit personnalisés de main, plus de possibilités pour les const fn et Manipulations statiques pour stdio verrouillé, « L'équipe Rust est heureuse d'annoncer une nouvelle version de Rust, 1.63. Rust est un langage de programmation qui permet à chacun de construire des logiciels fiables et efficaces », a déclaré l’équipe Rust.Rappelons que Rust est un langage de programmation compilé multiparadigme, conçu par Graydon Hore alors employé chez Mozilla Research, avec la contribution du créateur de JavaScript Brendan Eich. Utilisé par plusieurs grandes entreprises et par de nombreux développeurs dans le monde, Rust est devenu le langage de base pour certaines des fonctionnalités fondamentales du navigateur Firefox et de son moteur Gecko, ainsi que pour le moteur Servo de Mozilla.
Voici, ci-dessous, les nouveautés apportées par la version 1.63 de Rust :
Fils d'exécution délimités
Le code Rust peut lancer de nouveaux threads avec std::thread::spawn depuis la version 1.0, mais cette fonction délimite sa fermeture avec "static". En gros, cela signifie que les threads doivent actuellement avoir la propriété de tous les arguments passés dans leur fermeture ; vous ne pouvez pas passer de données empruntées dans un thread. Dans les cas où l'on s'attend à ce que les threads sortent à la fin de la fonction (en étant join()'d), cela n'est pas strictement nécessaire et peut nécessiter des solutions de contournement comme le placement des données dans un Arc.
Maintenant, avec la version 1.63.0, la bibliothèque standard ajoute les threads scopés, qui permettent de créer un thread empruntant le cadre de la pile locale. L'API std::thread::scope fournit la garantie nécessaire que tous les threads engendrés seront sortis avant que lui-même ne revienne, ce qui permet d'emprunter des données en toute sécurité. Voici un exemple :
| Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | let mut a = vec![1, 2, 3];
let mut x = 0;
std::thread::scope(|s| {
s.spawn(|| {
println!("hello from the first scoped thread");
// We can borrow `a` here.
dbg!(&a);
});
s.spawn(|| {
println!("hello from the second scoped thread");
// We can even mutably borrow `x` here,
// because no other threads are using it.
x += a[0] + a[2];
});
println!("hello from the main thread");
});
// After the scope, we can modify and access our variables again:
a.push(4);
assert_eq!(x, a.len()); |
Propriété Rust pour les descripteurs de fichiers/manches bruts (sécurité des E/S)
Auparavant, le code Rust travaillant avec des APIs de plateforme prenant des descripteurs de fichiers bruts (sur les plateformes de type unix) ou des handles (sur Windows) travaillait généralement directement avec une représentation du descripteur spécifique à la plateforme (par exemple, un c_int, ou l'alias RawFd). Pour les liaisons Rust à de telles API natives, le système de types n'arrivait pas à coder si l'API prenait la propriété du descripteur de fichier (par exemple, close) ou l'empruntait simplement (par exemple, dup).
Maintenant, Rust fournit des types enveloppants tels que BorrowedFd et OwnedFd, qui sont marqués comme #[repr(transparent)], ce qui signifie que les liaisons externes "C" peuvent directement prendre ces types pour encoder la sémantique de propriété. Voir la section API stabilisées pour la liste complète des types de wrapper stabilisés dans la 1.63. Actuellement, ils sont disponibles sur les plateformes cfg(unix), Windows et WASI.
l’équipe Rust recommande que les nouvelles API utilisent ces types au lieu des alias de types précédents (comme RawFd).
Initialisation des constantes Mutex, RwLock, Condvar
Les fonctions Condvar::new, Mutex::new, et RwLock::new sont maintenant appelables dans des contextes const, ce qui permet d'éviter l'utilisation de crates comme lazy_static pour créer des statiques globales avec des valeurs Mutex, RwLock, ou Condvar. Ceci s'appuie sur le travail effectué dans la 1.62 pour permettre des mutex plus fins et plus rapides sous Linux.
Turbofish pour les génériques dans les fonctions avec impl Trait
Pour une signature de fonction comme fn foo(value : T, f : impl Copy), c'était une erreur de spécifier le type concret de T via turbofish : foo::(3, 3) échouerait avec :
| Code : | Sélectionner tout |
1 2 3 4 5 6 7 | error[E0632]: cannot provide explicit generic arguments when `impl Trait` is used in argument position --> src/lib.rs:4:11 | 4 | foo::<u32>(3, 3); | ^^^ explicit generic argument not allowed | = note: see issue #83701 <https://github.com/rust-lang/rust/issues/83701> for more information |
Dans la version 1.63, cette restriction est assouplie et le type explicite du générique peut être spécifié. Cependant, le paramètre impl Trait, bien qu'il soit désugarisé vers un générique, reste opaque et ne peut pas être spécifié via le turbofish.
La migration des durées de vie non-lexicales est terminée
Comme détaillé dans ce billet de blog, léquipe Rust a entièrement supprimé l'ancien vérificateur d'emprunts lexicaux de rustc dans toutes les éditions, en activant entièrement la nouvelle version non-lexicale du vérificateur d'emprunts. Comme le vérificateur d'emprunts n'affecte pas la sortie de rustc, cela ne changera pas le comportement des programmes, mais cela termine une migration de longue haleine (commencée lors de la stabilisation initiale de NLL pour l'édition 2018) pour offrir tous les avantages du nouveau vérificateur d'emprunts dans toutes les éditions de Rust. Pour la plupart des utilisateurs, ce changement apportera des diagnostics légèrement meilleurs pour certaines erreurs de vérification d'emprunt, mais n'aura pas d'autre impact sur le code qu'ils peuvent écrire.
API stabilisées
Les méthodes et implémentations de traits suivantes sont maintenant stabilisées :
- array::from_fn
- Box::into_pin
- BinaryHeap::try_reserve
- BinaryHeap::try_reserve_exact
- OsString::try_reserve
- OsString::try_reserve_exact
- PathBuf::try_reserve
- PathBuf::try_reserve_exact
- Path::try_exists
- Ref::filter_map
- RefMut::filter_map
- NonNull::<[T]>::len
- ToOwned::clone_into
- Ipv6Addr::to_ipv4_mapped
- unix::io::AsFd
- unix::io::BorrowedFd<'fd>
- unix::io::OwnedFd
- windows::io::AsHandle
- windows::io::BorrowedHandle<'handle>
- windows::io::OwnedHandle
- windows::io::HandleOrInvalid
- windows::io::HandleOrNull
- windows::io::InvalidHandleError
- windows::io::NullHandleError
- windows::io::AsSocket
- windows::io::BorrowedSocket<'handle>
- windows::io::OwnedSocket
- thread::scope
- thread::Scope
- thread::ScopedJoinHandle
Ces API sont désormais utilisables dans des contextes de contrainte :
- array::from_ref
- slice::from_ref
- intrinsics::copy
- intrinsics::copy_nonoverlapping
- <*const T>::copy_to
- <*const T>::copy_to_nonoverlapping
- <*mut T>::copy_to
- <*mut T>::copy_to_nonoverlapping
- <*mut T>::copy_from
- <*mut T>::copy_from_nonoverlapping
- str::from_utf8
- Utf8Error::error_len
- Utf8Error::valid_up_to
- Condvar::new
- Mutex::new
- RwLock::new
Source : Rust
Et vous ?
Quel est votre avis sur le sujet ?Voir aussi :
Facebook rejoint AWS, Huawei, Google, Microsoft et Mozilla dans la Fondation Rust et renforce son équipe Rust par des nouveaux talents Microsoft annonce Rust preview pour Windows, alors que la comparaison entre Rust et C++ reste un sujet d'actualité Microsoft, Google, AWS, Huawei et Mozilla s'associent pour créer la Fondation Rust, une organisation à but non lucratif chargée de gérer le langage de programmation Rust 1.53.0 est disponible et s'accompagne de IntoIterator pour les tableaux, Cargo prend désormais en charge les référentiels git où la branche HEAD par défaut n'est pas "master" 
