Quoi de neuf dans le langage de programmation Rust

L’approche unique du langage de programmation Rust donne un meilleur code avec moins de compromis que C, C++, Go et les autres langages que vous utilisez probablement. Il est également mis à jour régulièrement, souvent tous les mois.

Où télécharger la dernière version de Rust

Si vous avez déjà une version précédente de Rust installée via rustup, vous pouvez accéder à la dernière version via la commande suivante :

$ rustup update stable

Les nouveautés de Rust 1.62

Rust 1.62, arrivé le 30 juin, permet aux développeurs d’ajouter des dépendances directement depuis la ligne de commande en utilisant cargo add. Cette commande prend en charge la spécification des versions et des fonctionnalités et peut également modifier les dépendances existantes. Rust 1.62 permet également l’utilisation de #[derive(Default)] sur les énumérations si une variante par défaut est spécifiée.

Autres nouvelles fonctionnalités de Rust 1.62 :

• La bibliothèque standard de Rust est désormais livrée avec une implémentation brute basée sur futex des verrous sous Linux, qui est légère et ne comporte aucune allocation supplémentaire. Cet ajout fait partie d’un effort visant à améliorer l’efficacité des types de serrures Rust.
• Il est maintenant plus facile de construire des binaires sans système d’exploitation pour x86_64, par exemple lors de l’écriture d’un noyau. La cible x86_64-unknown-none a été promue en Niveau 2 et peut être installé avec rustup.
• Un certain nombre d’API ont été stabilisées, notamment bool::then_some, f32::total_cmp, f64::total_cmp et Stdin::lines.

Les nouveautés de Rust 1.61

Publié le 19 mai, Rust 1.61 met en évidence les codes de sortie personnalisés de main. Les partisans de Rust ont dit qu’au début, Rust main seules les fonctions peuvent renvoyer le type d’unité () implicitement ou explicitement, indiquant le succès de l’état de sortie, et si les développeurs voulaient le contraire, ils devaient appeler process::exit. Depuis Rust 1.26, main a été autorisé à retourner un Resultoù Ok traduit en C EXIT_SUCCESS et Err à EXIT_Failure. Ces types de retour alternatifs ont été unifiés par un trait de terminaison instable. Dans cette version, Termination trait est stable, avec un plus général ExitCode type qui encapsule les types de retour spécifiques à la plate-forme. La Termination trait peut également être implémenté pour les propres types d’un développeur, permettant la personnalisation des rapports avant la conversion en un ExitCode.

Également dans la version 1.61 :

• Plusieurs fonctionnalités supplémentaires ont été stabilisées pour permettre plus de fonctionnalités dans const. Les développeurs peuvent désormais créer, transmettre et transtyper des pointeurs de fonction dans un const fn, ce qui peut être utile pour créer des tables de fonctions au moment de la compilation pour un interpréteur. Mais il n’est toujours pas permis d’appeler fn pointeurs. Les développeurs peuvent également désormais écrire des limites de traits sur des paramètres génériques pour const fntel que T: Copyoù auparavant seulement Sized était autorisé. Aussi, const fn peut maintenant traiter des objets de trait, alors que les arguments et les valeurs de retour pour const fn peut être opaque impl Trait les types.
• Les API ont été stabilisées telles que Pin::static_mut, Pin;;static_refet Vec::retain_mut.
• Auparavant, la création de poignées verrouillées pour stdin/stdlout/stderr empruntait les poignées étant verrouillées, ce qui empêchait d’écrire let out = std::io::stdout().lock(); car out survivrait à la valeur de retour de stdout(). Ce code fonctionne maintenant, éliminant un écueil courant affectant de nombreux utilisateurs de Rust.

Les nouvelles fonctionnalités de Rust 1.60.0

Rust 1.60, introduit le 7 avril 2022, stabilise la prise en charge de l’instrumentation de couverture basée sur LLVM dans rustc. Cela fournit une couverture de code basée sur la source. Les développeurs peuvent essayer cela en reconstruisant leur code avec -Cinstrument-coverage. Ensuite, l’exécution du binaire résultant produira un fichier default.profraw dans le répertoire courant.

La llvm-tools-preview le composant comprend llvm-profdata pour le traitement et la fusion de la sortie de profil brut, llvm-profdata pour le traitement de la sortie de fichier brut, et llvm-cov pour la génération de rapports. La fonctionnalité de base est stable et existera dans toutes les futures versions de Rust, mais le format de sortie spécifique et les outils LLVM qui le produisent sont susceptibles de changer. Les développeurs doivent utiliser la même version pour les deux llvm-tools-preview et le rustc binaire utilisé pour compiler le code.

Rust 1.60 réactive également la compilation incrémentielle. L’équipe Rust continue de travailler sur la correction des bogues de manière incrémentielle, mais aucun problème causant une casse généralisée n’est connu pour le moment.

Également dans Rust 1.60 :

• Sur toutes les plateformes, Instant essaiera d’utiliser une API de système d’exploitation qui garantit un comportement monotone si disponible. En pratique, ces garanties sont, dans de rares circonstances, brisées par des bogues matériels, de virtualisation ou de système d’exploitation. Pour contourner ces bogues et travailler avec des plates-formes dépourvues d’horloges monotones, Instant::duration_since, Instant::elapsedet Instant::sub maintenant saturer à zéro. Dans les anciennes versions de Rust, cela provoquait plutôt une panique.
• Cargo a mis en place un support pour la collecte d’informations sur la construction avec le --timings drapeau.
  
• Des dépendances à espace de noms et des fonctionnalités de dépendance faible ont été introduites pour améliorer la prise en charge des fonctionnalités Cargo et leur interaction avec les dépendances facultatives. Les fonctionnalités Cargo fournissent un mécanisme pour exprimer la compilation conditionnelle et les dépendances facultatives.
• Un certain nombre d’API ont été stabilisées telles que Arc::new_cyclic, Rc::new_cyclicet slice::EscapAscii.

Les nouvelles fonctionnalités de Rust 1.59.0

Rust 1.59.0 a été annoncé le 24 février. Une fonctionnalité clé est la prise en charge de l’assemblage en ligne, permettant à de nombreuses applications nécessitant un contrôle de très bas niveau sur l’exécution ou l’accès à des instructions machine spécialisées. Le langage d’assemblage et les instructions disponibles avec l’assemblage en ligne varient selon l’architecture. La fonctionnalité est actuellement prise en charge sur des architectures telles que x86 et x64, ARM, Risc-V et AArch64.

Autres nouvelles fonctionnalités et améliorations de Rust 1.59.0 :

• Les développeurs peuvent désormais utiliser des modèles de tranche, de tuple et de structure comme côté gauche d’une affectation, ce qui rend l’affectation plus cohérente avec let liaisons, qui prennent déjà en charge ces modèles.
• Les types génériques peuvent désormais spécifier des valeurs par défaut pour const génériques.
• Le gestionnaire de packages Cargo affiche désormais des avertissements lorsqu’une dépendance sera rejetée par une future version de Rust.
• Pour la création de binaires dépouillés, cargo et rustc prennent désormais en charge la suppression lorsque le binaire est lié. Les développeurs de Rust ont déclaré qu’il est souvent utile de supprimer les informations inutiles telles que les informations sur les bogues des fichiers binaires distribués, ce qui les rend plus petits.
• La compilation incrémentielle est désactivée par défaut. Cela atténue l’effet d’un bogue connu qui provoque des erreurs de désérialisation. Un correctif pour ce bogue sera disponible dans la version bêta de Rust 1.60 prévue dans six semaines.
• Un nombre de Les API ont été stabilisées.

Les nouvelles fonctionnalités de Rust 1.58.1

Cette version ponctuelle arrivant le 20 janvier 2022, quelques jours seulement après Rust 1.58, corrige une condition de concurrence dans le std::fs::remove_dir_all fonction de bibliothèque standard. Cette vulnérabilité est suivie à CVE-2022-21658 et il y avait un avis publié. Un attaquant pourrait utiliser ce problème de sécurité pour inciter un programme privilégié à supprimer des fichiers et des répertoires auxquels l’attaquant ne pourrait autrement pas accéder ou supprimer. Les versions Rust 1.0 à 1.58 sont affectées par cette vulnérabilité. Les utilisateurs sont invités à mettre à jour leurs chaînes d’outils et à créer des programmes avec le compilateur mis à jour.

Rust 1.58.1 corrige également plusieurs régressions dans les diagnostics et les outils introduits dans Rust 1.58 :

• La non_send_fields_in_send_ty La peluche Clippy s’est avérée avoir trop de faux positifs et a été déplacée vers le groupe expérimental de peluches appelé “pépinière”.
• La useless_format Clippy Lint a été mis à jour pour gérer les identifiants capturés dans les chaînes de format, introduits dans Rust 1.58.
• Une régression dans Rustfmt empêcher les fichiers générés d’être formatés lorsqu’ils sont passés par l’entrée standard a été corrigé.
• Un message d’erreur incorrect affiché par rustc dans certains cas a été corrigé.

Les nouveautés de Rust 1.58

Rust 1.58, annoncé le 13 janvier, propose des identifiants capturés dans des chaînes de format. Grâce à cette fonctionnalité, les chaînes de format peuvent désormais capturer des arguments en écrivant ident dans la chaîne. Les formats acceptent depuis longtemps les arguments de position et les arguments nommés, tels que :

println!("Hello, !", get_person());     // implicit position
println!("Hello, 0!", get_person());     // explicit index
println!("Hello, person!", person = get_person());     // named

Désormais, les arguments nommés peuvent également être capturés à partir de la portée environnante.

Autre nouveauté de Rust 1.58 : sur les cibles Windows, std::process::Command ne recherchera plus le répertoire courant pour les exécutables, ce qui était un effet du comportement historique de win32 CreateProcess API. Cela corrige une situation dans laquelle les recherches pouvaient entraîner un comportement surprenant ou des résultats malveillants lors de la gestion de répertoires non approuvés.

Rust 1.58 introduit également plus #[must_use] dans la bibliothèque standard. La #[must use] L’attribut peut être appliqué à des types ou à des fonctions lorsqu’ils ne les considèrent pas explicitement ou que leur sortie est presque certainement un bogue. Rust 1.58 a également des API stabilisées telles que Metadata::is_symlinkcode et Path::is_symlink.

Les nouveautés de Rust 1.57

Rust 1.57, dévoilé le 2 décembre, apporte panic! (pour terminer un programme dans un état irrécupérable) pour const contextes. Auparavant, le panic! la macro n’était pas utilisable dans const fn et d’autres contextes de compilation. Celle-ci est maintenant stabilisée. Parallèlement à la stabilisation de panic!plusieurs autres bibliothèques standard sont maintenant utilisables dans consttel que assert!. Mais cette stabilisation n’inclut pas encore toute l’infrastructure de formatage. La panic! macro doit être appelée avec une chaîne statique ou une seule valeur interpolée à utiliser avec . Ce soutien devrait s’étendre à l’avenir.

Autres nouvelles fonctionnalités et améliorations de Rust 1.57 :

• Cargo ajoute la prise en charge des profils nommés arbitrairement.
• try_reserve est stabilisé depuis Vec, String, HashMap, HashSetet VecDeque. Cette API permet aux appelants d’allouer de manière faillible un stockage de sauvegarde pour ces types.
• Plusieurs autres API ont été stabilisées, notamment [T; N]::as_mut_slice et [T; N]::as_slice.
• Les attributs de macro peuvent maintenant suivre #derive et verra l’entrée d’origine.

Les nouvelles fonctionnalités de Rust 1.56

Annoncée le 21 octobre, Rust 1.56 est la première version du langage qui prend en charge l’édition Rust 2021. L’édition Rust 2021 permet aux auteurs de caisses Rust d’opter pour des changements de langage qui rendent Rust plus facile à utiliser et plus cohérent. Les caisses peuvent s’inscrire à tout moment et rester interopérables avec les caisses des anciennes éditions. Le compilateur Rust prend en charge les trois éditions du langage : 2015, 2018 et 2021.

Les autres nouvelles fonctionnalités de Rust 1.56 incluent :

• Capture disjointe dans les fermeturespour simplifier l’écriture des fermetures.
• Cargo.toml prend désormais en charge un [package] [rust-version] champ pour spécifier la version minimale de Rust prise en charge pour une caisse, et Cargo se terminera avec une erreur précoce si cela n’est pas satisfait. Bien que cela n’influence pas actuellement le résolveur de dépendances, l’intention est de détecter les problèmes de compatibilité avant qu’ils ne se transforment en erreurs de compilateur cryptiques.
• Les nouvelles liaisons dans binding@pattern sont prises en charge. La correspondance de modèle de rouille peut être écrite avec un seul identifiant qui lie la valeur entière, suivi de @ et un modèle structurel plus raffiné, mais n’a pas autorisé de liaisons supplémentaires dans ce modèle jusqu’à présent. Cette fonctionnalité était autorisée avant Rust 1.0, mais a été supprimée en raison d’un problème. L’équipe du compilateur a maintenant déterminé que ce modèle est sûr et autorisé dans Rust stable.
• Les macros de panique attendent désormais toujours des chaînes de format, tout comme printlin!().
• Un certain nombre d’API ont été stabilisées, notamment std::os::unix::fs::chroot et UnsafeCell::raw_get.

Les nouveautés de Rust 1.55

Annoncé le 9 septembre 2021, Rust 1.55 offre une analyse flottante plus rapide et plus correcte. L’implémentation de la bibliothèque standard de l’analyse flottante a été mise à jour pour utiliser l’algorithme d’Eisel-Lemire, qui apporte des améliorations en termes de vitesse et d’exactitude. Auparavant, certains cas extrêmes n’étaient pas analysés, mais ceux-ci ont maintenant été corrigés.

Également dans Rust 1.55 :

• L’utilisation de plages ouvertes dans les modèles a été stabilisée.
• Un certain nombre de méthodes et d’implémentations de traits ont été stabilisées, notamment Bound::cloned et Drain::as_str.
• Cargo déduplique désormais les erreurs du compilateur et imprime un rapport à la fin de la compilation. Auparavant, lors de l’exécution cargo test, cargo check ---all targetsou des commandes similaires qui ont construit le même crate Rust dans plusieurs configurations, les erreurs et les avertissements peuvent apparaître en double car les exécutions rustc ont été exécutées en parallèle et ont montré le même avertissement.

Les nouveautés de Rust 1.54

Publié le 29 juillet, Rust 1.54 prend en charge l’appel de macros de type fonction à l’intérieur des attributs. Les macros de type fonction peuvent être des macros basées sur macro-rules! ou ils peuvent être des macros procédurales, qui sont appelées comme macro!(…). Un cas d’utilisation notable consiste à inclure la documentation d’autres fichiers dans les commentaires de la documentation Rust.

Autres nouvelles fonctionnalités de Rust 1.54 :