La version 1.35.0 de Rust est disponible
avec les traits de fermeture FnOnce, FnMut et Fn pour Box <dyn FnOnce>, Box <dyn FnMut> et Box <dyn Fn>, respectivement

Après la sortie de la version 1.34.0 il y a environ deux mois, l’équipe du développement du langage de programmation Rust vient d’annoncer la disponibilité de sa version 1.35.0. Le point fort de cette version est l'implémentation des traits de fermeture FnOnce, FnMut et Fn pour Box <dyn FnOnce>, Box <dyn FnMut> et Box <dyn Fn>, respectivement. De plus, les fermetures peuvent maintenant être forcées pour les pointeurs de fonction non sécurisés. La fonction dbg!(), la macro introduite depuis la version 1.32.0 de Rust peut maintenant aussi être appelée sans arguments.

Pour rappel, Rust est un langage de programmation compilé multiparadigme conçu et développé par Mozilla Research. Il a été conçu pour être « un langage sécurisé, concurrent, pratique », supportant les styles de programmation purement fonctionnel, modèle d'acteur, procédural, ainsi qu'orienté objet sous certains aspects. La version 1.34.0 est apparue en avril dernier avec l’opérateur “?” pour les tests de documentation, les registres alternatifs “cargo” et “fn before_exec” a été déprécié en faveur de “unsafe fn pre_exec”.

Dans le cas de l’opérateur “?” dans les tests de documentation, la RFC 1937 proposait d'ajouter un support pour l'utilisation de l’opérateur ? dans les fonctions fn main(), # [test] et doctests, leur permettant de renvoyer Option ou Result, avec des valeurs d'erreur générant un code de sortie non nul dans le cas de fn main(), et un échec de test dans le cas des tests. Les changements les plus notables dans cette version concernent l'implémentation des traits de fermeture FnOnce, FnMut et Fn, respectivement pour Box <dyn FnOnce>, Box <dyn FnMut> et Box <dyn Fn>. Parcourons quelques-uns de ces nouvelles fonctionnalités :

Les traits de fermeture Fn* mis en œuvre pour Box<dyn Fn*>

Dans Rust 1.35.0, les traits de fermeture FnOnce, FnMut et Fn sont maintenant mis en œuvre respectivement pour Box<dyn FnOnce>, Box<dyn FnMut> et Box<dyn Fn>. Auparavant, si vous vouliez appeler la fonction stockée dans une fermeture encadrée, vous deviez utiliser FnBox. Cela est dû au fait que les instances de Box<dyn FnOnce> et les traits Fn* respectifs n’étaient pas implémentés. Cela signifiait également qu'il n'était pas possible de passer des fonctions encadrées au code dans l'attente de l'implémenteur d'un trait Fn, et que vous deviez créer des fermetures temporaires pour les transmettre.

Ceci était dû en fin de compte à une limitation dans la capacité du compilateur à raisonner sur de telles implémentations, qui a depuis été corrigée avec l'introduction de sections locales non dimensionnées. Avec cette version, vous pouvez désormais utiliser des fonctions encadrées dans des endroits où des éléments implémentant un trait de fonction sont attendus. De plus, vous pouvez maintenant forcer la fermeture des indicateurs fn dangereux.

Nom : 1*5KIIZPyW3QCo0YSiVXtoWA.png
Affichages : 1206
Taille : 8,7 Ko

Appelez désormais dbg!() sans arguments

Pour le bénéfice de tous les “débogueurs d'impression” occasionnels et fréquents, Rust 1.32.0 a vu la sortie de la macro dbg!. Pour récapituler, la macro vous permet d'inspecter rapidement la valeur d'une expression avec un contexte. La macro fonctionne en utilisant l’implémentation Debug du type de l’expression donnée pour imprimer la valeur sur stderr avec l’emplacement source de l’appel de macro ainsi que le code source de l’expression. Vous pouvez désormais appeler dbg! sans lui passer aucun argument. Ceci est utile pour tracer toutes les différentes branches de votre application.

Dans la version 1.35.0 du langage, un certain nombre d'API et de bibliothèques sont devenues stables. Quelques autres modifications et de nouvelles implémentations ont également été apportées. Certaines de ces nouveautés sont présentées comme ci-dessous :

  • vous pouvez copier le signe d'un nombre à virgule flottante sur un autre : dans cette version, de nouvelles méthodes, copysign, ont été ajoutées aux types primitifs à virgule flottante f32::copysign et f64::copysign. Comme leur nom l'indique, vous pouvez les utiliser pour copier le signe d'un nombre sur un autre. Par exemple :
    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    fn main() {
        assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    };
  • vous avez désormais la possibilité de vérifier si une plage contient une valeur donnée : Rust 1.35.0 contient quelques méthodes fraîchement imprimées sur les types de la gamme : Range::contains, RangeFrom::contains, RangeTo::contains, RangeInclusive::contains et RangeToInclusive::contains. Avec ceux-ci, vous pouvez facilement vérifier si une valeur donnée existe dans une plage. Par exemple, vous pouvez écrire :
    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    fn main() {
        if (0..=10).contains(&5) {
            println!("Five is included in zero to ten.");
        }
    };
  • vous pouvez mapper et diviser une valeur RefCell empruntée en deux : avec Rust 1.35.0, vous pouvez maintenant mapper et diviser la valeur empruntée d’une RefCell en plusieurs emprunts pour différentes composantes des données empruntées : Ref::map_split et RefMut::map_split ;
  • vous pouvez désormais remplacer la valeur d'une RefCell par une fermeture : cette version du langage introduit une méthode pratique du nom de replace_with sur RefCell. Grâce à elle, vous pouvez mapper et remplacer de manière plus ergonomique la valeur actuelle de la cellule et récupérez l’ancienne valeur ;
  • il existe un nouveau ou une référence par adresse : Hash (ptr::hash) est un pointeur ou une référence par adresse, pas de valeur. Cette fonction prend un pointeur brut et le hashe. En utilisant ptr::hash, vous pouvez éviter de hacher la valeur pointée d'une référence, mais plutôt hacher l'adresse ;
  • vous pouvez copier le contenu d'une Option<&T> : depuis le tout début avec Rust 1.0.0, les méthodes Option::cloned pour Option<&T> et Option<& mutT> vous ont permis de cloner le contenu dans le cas de Some(_). Cependant, le clonage peut parfois être une opération coûteuse et les méthodes opt.cloned() ne fournissent aucune indication à cet effet. De ce fait, cette version de Rust introduit Option::copied pour les deux options Option<&T> et Option<& mutT>. La fonctionnalité de opt.copied() est la même que celle de opt.cloned(). Cependant, l'appel de la méthode nécessite T:Copy. En utilisant cette méthode, vous pouvez vous assurer que le code cesse de compiler si T n’implémente plus Copy.

Dans cette version de Rust, Clippy, la collection de lint pour attraper les erreurs courantes et améliorer votre code Rust, a ajouté un nouveau lint dénommé drop_bounds. Cette peluche se déclenche lorsque vous ajoutez une liaison T: Drop à une fonction générique. Par exemple : fn foo<T: Drop>(x: T) {}. En plus de drop_bounds, cette version de Clippy scinde lintredundant_closure en deux différentes méthodes notamment redundant_closure et redundant_closure_for_method_calls. En outre, il existe d’autres changements et d’ajouts dans les registres alternatifs. Vous pouvez consulter la note de version de Rust 1.35.0 pour avoir plus d'informations sur les nouveautés dans le langage.

Source : Billet de blog

Et vous ?

Qu'en pensez-vous ?
Quelle fonctionnalité vous a le plus attiré dans la version 1.35.0 de Rust ?
Quelles autres fonctionnalités souhaiteriez-vous avoir pour la prochaine version du langage ?

Voir aussi

Rust 1.34.0 est disponible en version stable et apporte le support de l'opérateur "?" dans les tests de documentation

L'équipe de npm choisit Rust pour gérer les goulots d'étranglement liés au CPU au détriment de Go, C, C++ et Java. Voici les raisons de ce choix

Rust, en bref