IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

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.63 est disponible et s'accompagne des fils d'exécution délimités,
Des propriété Rust pour les descripteurs de fichiers

Le , par Bruno

53PARTAGES

5  0 
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"

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

Avatar de Uther
Expert éminent sénior https://www.developpez.com
Le 13/08/2022 à 8:04
En effet, au début il y avait un autre système de scoped thread plus simple de prévu, mais il a été abandonné avant la version 1.0 car il dépendait pour sa sécurité sur le fait que les objets étaient systématiquement libérés, ce que Rust ne garantit pas : on peut par exemple faire des cycles de Rc ou utiliser des fonctions comme Box::leak().
2  0 
Avatar de Pyramidev
Expert éminent https://www.developpez.com
Le 13/08/2022 à 3:07
L'utilisation de std::thread::scope permet de pratiquer la programmation concurrente structurée, un paradigme qui est très bien expliqué dans un excellent article de Nathaniel J. Smith : Notes on structured concurrency, or: Go statement considered harmful.

C'est un plaisir que Rust le supporte enfin directement dans la bibliothèque standard ! &#129395;

Je viens de tester std::thread::scope en modifiant quelques POC sur mon PC, dont un code adapté du projet du chapitre 20 du Rust Book.

J'ai pu effectivement me débarrasser de Arc. En contrepartie, le code est plus volumineux. Par exemple, j'ai dû passer un objet s: &'scope Scope<'scope, 'env> de paramètre en paramètre, avec les durées de vie qui vont avec.
1  0