La sortie du langage de programmation polyvalent Rust 1.61, fondé par le projet Mozilla, mais maintenant développé sous les auspices de l'organisation indépendante à but non lucratif Rust Foundation, a été publiée. Le langage se concentre sur la sécurité de la mémoire et fournit les moyens d'atteindre un parallélisme élevé des tâches tout en évitant l'utilisation d'un ramasse-miettes et d'un temps d'exécution (le temps d'exécution est réduit à l'initialisation et à la maintenance de base de la bibliothèque standard).
Les méthodes de gestion de la mémoire de Rust évitent au développeur les erreurs lors de la manipulation des pointeurs et protègent contre les problèmes qui surviennent en raison de la gestion de la mémoire de bas niveau, comme l'accès à une zone mémoire après qu'elle a été libérée, le déréférencement des pointeurs nuls, les dépassements de mémoire tampon, etc. Pour distribuer les bibliothèques, fournir des builds et gérer les dépendances, le projet développe le gestionnaire de packages Cargo. Le référentiel crates.io est pris en charge pour l'hébergement de bibliothèques.
La sécurité de la mémoire est fournie dans Rust au moment de la compilation grâce à la vérification des références, au suivi de la propriété des objets, au suivi des durées de vie des objets (portées) et à l'évaluation de l'exactitude de l'accès à la mémoire pendant l'exécution du code. Rust fournit également une protection contre les débordements d'entiers, nécessite une initialisation obligatoire des valeurs de variables avant utilisation, gère mieux les erreurs dans la bibliothèque standard, applique le concept de références et de variables immuables par défaut, propose un typage statique fort pour minimiser les erreurs logiques.
Principales nouveautés :
- Il est possible de définir vos propres codes retour depuis la fonction principale. À l'origine, la fonction principale de Rust ne pouvait renvoyer que le type "()" (unité), qui indiquait toujours un statut de sortie réussi à moins que le développeur n'appelle explicitement la fonction "process::exit(code)". Dans Rust 1.26, en utilisant le trait de terminaison unstable dans la fonction principale, il était possible de renvoyer les valeurs « Ok » et « Err », correspondant aux codes EXIT_SUCCESS et EXIT_FAILURE dans les programmes C. Dans Rust 1.61, le trait Termination a été rendu stable et un type ExitCode distinct a été proposé pour représenter un code de retour spécifique, qui résume les types de retour spécifiques à la plate-forme en fournissant à la fois les constantes prédéfinies SUCCESS et FAILURE, ainsi que la méthode From. pour renvoyer un code retour personnalisé. utilisez std :: process :: ExitCode ; fn main() -> ExitCode { if !check_foo() { return ExitCode::from(8); } Code de sortie :: SUCCÈS }
- Des capacités supplémentaires des fonctions définies à l'aide de l'expression « const fn » ont été stabilisées, qui peuvent être appelées non seulement comme fonctions régulières, mais également utilisées dans n'importe quel contexte au lieu de constantes. Ces fonctions sont calculées au moment de la compilation et non au moment de l'exécution. Elles sont donc soumises à certaines restrictions, telles que la possibilité de lire uniquement à partir de constantes. Dans la nouvelle version, les opérations de base avec des pointeurs de fonction sont autorisées à l'intérieur des fonctions const (la création, le passage et la conversion de pointeurs sont autorisés, mais pas l'appel d'une fonction par pointeur) ; limites de traits pour les paramètres génériques des fonctions const telles que T: Copy ; traits distribuables dynamiquement (dyn Trait); impl Types de traits pour les arguments de fonction et les valeurs de retour.
- Le flux gère Stdin, Stdout et Stderr dans std::io ont désormais une durée de vie statique (« 'static ») lorsqu'il est verrouillé, permettant des constructions telles que « let out = std::io::stdout().lock(); » avec obtenir une poignée et définir un verrou en une seule expression.
- Une nouvelle partie de l'API a été déplacée vers la catégorie stable, dont les méthodes et les implémentations des traits ont été stabilisées :
- Pin :: static_mut
- Épingle ::static_ref
- Vec ::retain_mut
- VecDeque ::retain_mut
- Écrire pour le curseur<[u8; N]>
- std :: os :: unix :: net :: SocketAddr :: from_pathname
- std :: processus :: Code de sortie
- std :: processus :: Résiliation
- std :: thread :: JoinHandle :: is_finished
- L'attribut « const », qui détermine la possibilité de l'utiliser dans n'importe quel contexte à la place de constantes, est utilisé dans les fonctions :
- <*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
De plus, vous pouvez noter l'article « Rust : A Critical Retrospective » avec un résumé des impressions du langage Rust après y avoir écrit 100 XNUMX lignes de code lors du développement du système d'exploitation du micronoyau Xous utilisé dans le firmware. Les inconvénients incluent une syntaxe difficile à comprendre, le caractère incomplet et le développement continu du langage, le manque de versions reproductibles, les problèmes typiques de confiance en dépendance dans Crates.io et la nécessité de maintenir une certaine discipline pour écrire du code sécurisé. Les fonctionnalités qui ont dépassé les attentes incluent des outils de refactorisation du code et de remaniement des « hacks » ajoutés lors du prototypage rapide.
Source: opennet.ru