Rust 1.2 disponible en version stable avec la bêta de Rust 1.3
Le langage de programmation de Mozilla améliore de 30% le temps de compilation

Le , par Hinault Romaric

0PARTAGES

1  0 
Fidèle au cycle de développement rapide de son langage de programmation Rust, la fondation Mozilla vient d’annoncer dans un billet de blog la sortie de Rust 1.2.

Pour rappel, Rust est un langage de programmation compilé, multiparadigme (orienté objet, fonctionnel et procédural) qui tire parti des langages fonctionnels comme Haskell et ML, du langage orienté objet C++ et bien plus.

Avec Rust, Mozilla offre la sécurité et la commodité des langages modernes, tout en maintenant l’efficacité et le contrôle de bas niveau des langages C et C++. Le langage de programmation est vu comme une alternative à C/C++, qui s’inspire des éléments qui ont fait leur succès, mais qui offre en plus une meilleure sécurité.

Selon la fondation Mozilla, il s’agit d’un langage de programmation visant à rendre plus facile le développement des systèmes fiables et efficaces. Rust est « orienté objet statique, typé, sûr, concurrentiel et efficace », d’après ses développeurs.

Le langage de programmation a atteint sa première version stable en avril dernier. À partir de cette période, Mozilla a adopté un cycle de développement inspiré du système de canaux utilisé pour Firefox et Chrome. Les évolutions de la plateforme peuvent être suivies au travers des canaux Nightly, Beta et Stable, qui sont mis à jour toutes les six semaines.

De ce fait, Rust 1.2 sort avec la version bêta de Rust 1.3.


Des améliorations de performances sont au centre de cette version. Ses développeurs notent une amélioration de la vitesse de compilation de 30% par rapport à Rust 1.1. La compilation pour Cargo est également plus rapide de 18%.

Rust 1.2 apporte la prise en charge de Parallel codegen, ce qui permet une accélération de 30% lors de l’amorçage sur une machine ayant 4 cœurs. Parallel codegen est particulièrement utile pour les versions debug, car il empêche certaines optimisations.

Le gestionnaire de packages Cargo a bénéficié de plusieurs autres améliorations de performances. Il prend désormais en charge les répertoires cibles partagés. Cela permet un gain de temps non négligeable pour des projets complexes.

Rust 1.2 offre une prise en charge préliminaire de MSVC (Microsoft Visual C). Selon les développeurs du langage, cela représente un grand pas pour la prise en charge de Windows et rend plus facile la liaison entre le code Rust et le code compilé en utilisant la chaine de compilation native.

En ce qui concerne le langage, Rust 1.2 marque l’achèvement du support du type dynamically-sized (DST). Cette fonctionnalité permet l’utilisation des pointeurs intelligents sur des types existants comme [T] et Trait. Les DTS sont des types dont la taille est inconnue du compilateur.

Les développeurs trouveront sur le canal bêta Rust 1.3. Cette version accorde également une place importante à l’optimisation des performances. Elle offre aussi une prise en charge préliminaire de Windows XP. « Bien que nous ne voulons pas traiter Windows XP comme une plateforme de ‘premier niveau’, il est maintenant possible de compiler le code Rust pour Windows XP aussi longtemps que vous évitez certaines parties de la bibliothèque standard », écrivent les développeurs de Rust.

Rust 1.2 a été développé avec la collaboration de 180 développeurs à travers le monde.

Télécharger Rust 1.1 et Rust 1.2 bêta

Source : Blog Rust

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

Avatar de Malick
Community Manager https://www.developpez.com
Le 18/09/2015 à 21:28
Rust 1.3 est maintenant disponible en version stable
le langage de programmation de Mozilla améliore de 30% le temps de compilation


Toujours fidèle au cycle de développement rapide de son langage de programmation baptisé Rust, la fondation Mozilla a annoncé, dans un billet de blog, la sortie de Rust 1.3 en version stable.

Rappelons que Rust est un langage de programmation compilé, orienté objet, fonctionnel et procédural. Il est inspiré des langages fonctionnels comme Haskell et ML, du langage orienté objet C++ etc. et a comme principal objectif le développement de systèmes fiables et efficaces avec une grande facilité.

La sortie de Rust 1.3 intervient un peu plus de deux mois après l'annonce de Rust 1.1 et un mois après la disponibilité de Rust 1.2.

Rust 1.3 est livré avec un nouveau livre dénommé The Rustonomicon :The Dark Arts of Advanced and Unsafe Rust Programming . Ce livre traiterait l'essentiel des éléments relatifs à la sécurité qu'il est indispensable de comprendre pour écrire des programmes corrects.

Selon la fondation Mozilla, Rust 1.3 apporte de nouvelles fonctionnalités parmi lesquelles nous pouvons citer :
  • au niveau de la bibliothèque avant, une amélioration de la stabilité de l'API incluant une nouvelle durée et une amélioration de l'interface des erreurs Hash/Hasher ;
  • l'utilisation d'un algorithme plus efficace par l'adaptateur de chaîne ;
  • des améliorations à remplissage zéro afin d'accélérer Vec::resize et Read::read_to_end ;
  • l'implémentation de Read::read_to_end a été spécialement réalisée pour stdin and File résultant des accélérations supplémentaires ;
  • l'implémentation du PartialEq est maintenant beaucoup plus rapide.


Les développeurs avaient aussi soutenu que Rust 1.3 accorde une place importante à l’optimisation des performances. Ceci étant, ce langage offre une prise en charge préliminaire de Windows XP. Les développeurs avaient également affirmé qu'ils ne voulaient pas traiter Windows XP comme une plateforme de premier niveau, et qu'il est maintenant possible de compiler le code Rust pour Windows XP aussi longtemps que certaines parties de la bibliothèque standard seront évitées.

Rust 1.3 a été développé avec la collaboration de 131 développeurs à travers le monde et la version stable est disponible en téléchargement ici.

Source : blog Rust

Et vous ?
Que pensez-vous de cette version stable de Rust 1.3 ?
Allez-vous l'essayer ?
Avatar de matthius
Membre éprouvé https://www.developpez.com
Le 20/09/2015 à 19:24
L'utilisation d'un "=>" pour le match du case, anciennement ":" pour le C peut sembler fastidieuse à l'utilisation, donc inutile.
Mais cela permet peut-être de mieux trouver les erreurs pour le développeur. Est-ce vrai ?

L'intérêt par rapport au Pascal semble donc le temps gagné, si c'est le cas, une jolie présentation, l'utilisation facilitée des objets dans les boucles.
Avatar de Uther
Expert éminent sénior https://www.developpez.com
Le 21/09/2015 à 7:41
Le ":" sert déjà à annoter le type en Rust, donc il n'aurait pas vraiment été adapté au match. Utiliser deux caractères par élément de match, c'est vraiment pas ce que j'appelle de la lourdeur. D'ailleurs la syntaxe reste quand même plus légère que celle du C vu que l'on a pas à mettre "case" à chaque élément. De plus le fait que le match utilise le pattern matching permet également de simplifier pas mal de cas qui seraient beaucoup plus complexes en C.

Le "match" a moins de risque d'erreur que le "switch" en C, mais ce n'est pas à cause du "=>". C'est surtout du au fait que le "match" se doit d'être exhaustif : si un match ne capture pas tous les cas possibles, le programme refusera de compiler. De plus le fait que l'on utilise des blocs et pas, comme en C, une suite d’instruction qu'il faut généralement terminer par un break permet de diminuer le risque d'erreur.
Avatar de _skip
Expert éminent https://www.developpez.com
Le 21/09/2015 à 11:01
Je suis ce projet depuis ses débuts, je suis plutôt bien disposé à l'idée d'avoir un langage "moderne" positionné quelque part entre java et C++.
Si quelqu'un a des retours sur un usage en production ou même un projet interne, je suis preneur.
Avatar de Olivier Famien
Chroniqueur Actualités https://www.developpez.com
Le 12/12/2015 à 11:22
Rust 1.5 est disponible en version stable
avec une nouvelle commande permettant au gestionnaire de package d’installer des packages localement

La Fondation Mozilla vient d’annoncer la disponibilité de Rust 1.5 en version stable. Pour cette nouvelle version, il faut compter environ 700 changements et de nombreux correctifs de bogues.


Parmi les nouvelles fonctionnalités, le point le plus important demeure l’introduction de la nouvelle commande « Cargo install » permettant d’installer localement sur le système les packages d’application hébergés sur la plateforme crates.io.

Nous rappelons que cette fonctionnalité a été depuis longtemps réclamée par les développeurs afin de pouvoir installer des packages qui sont hors du manifest. En réponse, Mozilla avait intégré la mise en œuvre de cet outil dans sa feuille de route couvrant les futures fonctionnalités de Rust.

Dans cette présentation, trois axes avaient été définis parmi lesquels l’implémentation de fonctionnalités permettant au gestionnaire de packages Cargo d’installer des binaires. Cela aurait pour avantage d’offrir aux développeurs Rust des moyens plus aisés pour partager les applications Rust.

Avec cette nouvelle itération, les développeurs peuvent utiliser la nouvelle commande Cargo install pour installer des applications, mais également pour installer de nouvelles sous-commandes pour cargo lui-même. Comme nouvelles sous-commandes disponibles pour étendre les fonctionnalités de Cargo, nous avons par exemple :

  • cargo-count : qui permet d’afficher les statistiques telles que le code, les commentaires, les compteurs concernant les projets ;
  • cargo-graph : cette sous-commande permet de construire les fichiers GraphViz DOT des graphes de dépendance ;
  • cargo-edit : qui permet d’ajouter une fonctionnalité à Cargo afin d’éditer des dépendances pour un projet à partir d’une ligne de commande ;
  • cargo-readme : permettant de générer du contenu README.md à partir des commentaires de la documentation ;
  • cargo-check : permettant de vérifier un projet de manière statique sans toutefois produire de binaire ;
  • cargo-script : qui permet d’exécuter des scripts Rust assez facilement en se servant de l’écosystème de package de Rust ;
  • Cargo-watch : qui permet de réexécuter une commande de Cargo lorsque des modifications sont effectuées dans le projet ;
  • cargo-extras : est une collection de sous-commandes de Cargo ;
  • cargo-outdated : est une sous-commande de Cargo pour l’affichage lorsque les dépendances sont obsolètes.


À côté de ces fonctionnalités, Rust 1.5 connait également un certain nombre de stabilisations au niveau des API de bibliothèques. À ce sujet, nous avons de manière non exhaustive les API suivantes qui ont été améliorées : BinaryHeap::from, BinaryHeap::into_sorted_vec, FileTypeExt::is_block_device, FileTypeExt::is_char_device, Formatter::alternate, Formatter::fill, Iterator::cmp, Iterator::eq, Path::canonicalize, Path::exists, Utf8Error::valid_up_to, Vec::resize, VecDeque::as_mut_slices, slice::split_first_mut, slice::split_first, str::MatchIndices, str::RMatchIndices.

En outre, lorsque vous créez des packages, les dépendances d’un crate sont associées à des contraintes qui exigent de définir les versions de dépendances avec lesquelles ce crate est compatible. Ces versions de dépendances peuvent être de l’ordre d’une seule version précisée de cette manière (=1.2.3), de plusieurs versions (^1.2.3, ~1.2.3, >= 1.2.3, < 3.0.0) ou de toutes les versions de dépendance matérialisées par le caractère générique (*).

Nous rappelons en outre qu’un crate est une unité de compilation qui peut servir à générer une bibliothèque ou un package. Et pour cette nouvelle version de Rust, le processus RFC (Request For Comments) de la communauté Rust a proposé la mise à jour de crates.io afin de rejeter les publications de crates utilisant une contrainte de version générique pour définir les dépendances de compilation et de construction de build associées au projet.

En conséquence, les crates utilisant les dépendances avec le caractère générique (*) dans cette version 1.5 déclencheront des avertissements à la publication. Et pour la version 1.6, il ne sera plus possible de publier des crates associant des dépendances avec le caractère générique (*).

Enfin, Mozilla annonce dans cette nouvelle mouture des améliorations au niveau du temps de compilation et une réduction des métadonnées de crate d’environ 20 %. Plusieurs autres améliorations et nouvelles fonctionnalités sont disponibles au niveau du langage, de bibliothèques, des divers et bien d’autres encore.

Source : Blog Rust

Et vous ?

Que pensez-vous des nouvelles fonctionnalités de Rust 1.5 ?

Quelles sont les améliorations que vous souhaitez voir dans les prochaines versions de Rust ?

Voir aussi

Forum Autres langages
Avatar de Michael Guilloux
Chroniqueur Actualités https://www.developpez.com
Le 26/01/2016 à 8:55
Rust 1.6 est disponible en version stable
La bibliothèque libcore du langage de programmation de Mozilla est maintenant stable

Rust, le langage de programmation compilé multiparadigme de Mozilla est disponible en version 1.6 avec un accent mis sur la stabilisation des bibliothèques. La plus grande nouveauté annoncée dans la nouvelle version du langage de programmation des systèmes axés sur la sécurité, la rapidité et la concurrence est sans doute le fait que la bibliothèque libcore est maintenant stable.

La bibliothèque standard de Rust est à deux niveaux avec libcore, qui est une bibliothèque minimaliste de base sur laquelle est construite la bibliothèque standard complète libstd. La bibliothèque de base libcore fournit les types de données et fonctions les plus fondamentaux pris en charge par Rust, et est indépendante de la plateforme. La bibliothèque libstd, quant à elle, vient ajouter à libcore le support pour l’allocation de la mémoire, les entrées/sorties, et la concurrence.

La bibliothèque libcore est préférée pour l’embarqué utilisant Rust et l’écriture de systèmes d’exploitation, mais cette bibliothèque a depuis toujours été instable. La stabilisation de libcore permet donc au langage de programmation orienté bas niveau de se rapprocher de l’accomplissement de l’une des principales missions pour lesquelles il a été initialement conçu, c’est-à-dire permettre aux développeurs de construire des logiciels niveau système. « Stabiliser libcore est une étape majeure vers la capacité d’écrire les plus bas niveaux de logiciels en utilisant Rust stable », explique l’équipe Rust qui ajoute encore que « cela permettra de développer un écosystème de bibliothèque autour de libcore ».

Dans cette nouvelle version de Rust, on note aussi une trentaine de fonctions et méthodes de bibliothèque qui ont été stabilisées et environ 1100 correctifs.

Un changement a été également apporté à crates.io, la plateforme officielle pour rechercher et installer les paquets Rust. Jusqu’à la version 1.5 de Rust, pour définir les versions des dépendances d’un crate, il était possible d’utiliser le métacaractère (*). Un crate est l’équivalent Rust pour « bibliothèque » ou « paquet » dans d’autres langages. L’utilisation du métacaractère (*) indique que votre projet marche avec toutes les versions de la dépendance citée, « ce qui est hautement improbable pour être vrai », d’après l’équipe Rust qui ajoute encore que cela est à l’origine d’un certain nombre de ruptures inutiles dans l’écosystème.

Dans la version 1.5, une mise à jour de Crates.io a donc été proposée afin de rejeter les publications de crates utilisant le métacaractère pour définir les dépendances associées au projet. L’équipe Rust avait donc introduit des avertissements qui se déclenchent à la publication d’un crate utilisant les dépendances avec le caractère générique (*). Dans la version 1.6, il n’est plus possible de publier des crates dont les versions des dépendances sont définies avec le métacaractère (*). Il faudra désormais spécifier une version ou un intervalle de versions. Autrement dit, la spécification suivante ne sera plus acceptée :
Code : Sélectionner tout
1
2
[dependencies]
regex = " * "
Il faudra utiliser les options ^, ~ ou =.

De nombreux autres petits changements ont été apportés dans Rust 1.6. On peut par exemple noter que plusieurs fonctions de minuterie qui utilisent les millisecondes sont maintenant obsolètes. Le parser vous avertira également si une erreur a été causée par des caractères Unicode qui se ressemblent, mais sont interprétés différemment.

Sources : Blog Rust, Notes de version Rust 1.6

Et vous ?

Que pensez-vous des nouveautés dans cette nouvelle version stable de Rust ?

Voir aussi :

Rust se lance à la conquête des développeurs C/C++, Mozilla publie la première version stable de son langage de programmation multiparadigme
En 2016, Firefox pourrait accueillir du code Rust et des composants de Servo, le moteur de rendu web sécurisé de Mozilla
Rust : Mozilla dévoile ses projets pour l'année à venir, et entend améliorer Crates, réduire les erreurs et emmener Rust sur de nouveaux territoires
Avatar de Olivier Famien
Chroniqueur Actualités https://www.developpez.com
Le 05/03/2016 à 0:35
Mozilla annonce la disponibilité de Rust 1.7 en version stable
avec un accent mis sur la stabilisation des méthodes et fonctions des bibliothèques

Un peu plus d’un mois après la sortie de la version 1.6, l’équipe de Rust vient d’annoncer la disponibilité de la version stable de Rust 1.7. Tout comme la version 1.6, un accent particulier a été mis sur les fonctionnalités des bibliothèques Rust.

Pour cette nouvelle version, environ 40 fonctions et méthodes ont été rendues stables. Au nombre de celles-ci, l’on a par exemple la fonction relative_from permettant de retourner un chemin, qui a été dépréciée et renommée en strip_prefix. La méthode is_loopback(&self) retourne la valeur « vrai » si l’adresse à vérifier est une adresse Loop back selon le registre RFC 6890.

Par ailleurs, pour copier les données d’un slice (une vue dans une région de mémoire) afin de l’insérer dans un autre slice, il faut utiliser la méthode <[T]>::clone_from_slice(). En ce qui concerne CString, plusieurs améliorations ont été également apportées afin d’utiliser du code C à partir de l’interface FFI.

Mais au-delà de ces éléments, le point le plus important pour ce qui est de la stabilisation des fonctions et méthodes, c’est le support des algorithmes de hachage personnalisé contenu dans le type HashMap<K, V> de la bibliothèque standard de Rust. Il faut rappeler qu’auparavant tous les dictionnaires de hachage utilisaient l’algorithme de hachage SipHash pour assurer la protection par défaut contre les attaques par déni de service. Toutefois, cet algorithme présente des inconvénients en matière de performance lorsqu’il s’agit de hacher de petites clés.

Pour résoudre le problème, vous pouvez basculer sur l’algorithme de hachage FNV qui montre des performances meilleures en matière de hachage de ce type de clés. En outre, il est bon de savoir que ce gain de performance se fait au détriment de la protection contre les attaques par déni de service. Si cela ne vous pose aucun problème, vous pouvez alors adopter ce dernier, suggère l’équipe de Rust.

En dehors du point d’honneur qui a été mis sur les fonctions et les méthodes, l’on a quelques améliorations au niveau des fonctionnalités de Cargo, le gestionnaire de package. Ainsi, il a été introduit des ajouts permettant d’avertir le gestionnaire lorsque des changements surviennent au niveau des dépendances. Cela a l’avantage de déclencher une réexécution des scripts de construction seulement lorsque des changements ont eu lieu dans les dépôts des dépendances et non de manière aléatoire.

À ces différents changements, il faut ajouter la modification de la sous-commande rustc afin de pouvoir compiler les objets ciblés dans plusieurs profils disponibles (dev, brench, test). À côté de ces éléments, il faut souligner que la collection BTreeMap a été réécrite afin d’utiliser moins de mémoire et améliorer les performances des insertions et des itérations.

De nombreuses autres améliorations ont été implémentées dans cette nouvelle version et environ 1300 correctifs ont été intégrés.

Source : Blog Rust

Et vous ?

Que pensez-vous de cette nouvelle version de Rust ? Est-elle à la hauteur de vos attentes ?

Voir aussi

Forum Autres langages
Avatar de Olivier Famien
Chroniqueur Actualités https://www.developpez.com
Le 17/04/2016 à 3:41
Rust 1.8 est disponible
avec la possibilité de surcharger les opérateurs d’affectation à travers les traits et un nouveau projet pour remplacer Make

L’équipe de Rust vient d’annoncer la sortie de la version 1.8 de ce langage de programmation. Dans cette nouvelle version, plusieurs améliorations ont été introduites. Un nombre important de bibliothèques ont été rendues stables, les performances du compilateur ont été améliorées et Cargo, le gestionnaire de package, s’est doté de nouvelles fonctionnalités.

De manière détaillée, on note qu’il est maintenant possible de surcharger les opérateurs d’affectation (+= et -=) à travers les traits. Nous rappelons qu’un trait est un outil du langage Rust qui offre au compilateur des informations sur les fonctionnalités qu’un type doit fournir. Étant donné qu’il peut être associé à un autre type, ces traits peuvent être utilisés pour définir d’avance le comportement d’un type dans un cas précis. D’autres personnes pourront également exploiter cet avantage pour limiter les types que leurs fonctions génériques acceptent. Et pour ce qui concerne cette nouvelle fonctionnalité permettant de surcharger les opérateurs d’affectation, il faut ajouter qu’il est également possible d’utiliser des types différents de part et d’autre de l’opérateur.

À côté de cela, Mozilla a validé l’écriture d’un struct sans accolades. Avant la version 1.8 de Rust, un struct sans aucun champ ne devait pas posséder d’accolades, comme le code suivant :

Code : Sélectionner tout
1
2
struct Foo; // fonctionne
struct Bar { } // erreur
À partir de cette version 1.8, le second code ne génère plus de message d’erreur.

En plus de ces nouveautés, un clin d’œil a été également fait aux utilisateurs Windows. En effet LLVM, l’infrastructure de compilateur a été améliorée afin de détecter les nouvelles instructions de gestion des exceptions pour les builds 32 bits issues de l’environnement de développement intégré pour les langages de programmation C et C++ (MSVC).

Toujours à propos des nouveautés de cette nouvelle version de Rust, l’équipe de Rust informe que des travaux sont en cours afin de mettre sur pied un nouvel outil pour construire les fichiers Rust. Depuis toujours, Make a été l’outil privilégié pour construire les programmes et bibliothèques Rust. Mais avec le succès de Cargo, un nouveau projet écrit avec Rust et basé sur Cargo a vu le jour avec pour objectif de remplacer Make dans la construction des fichiers et programmes Rust.

Abordant le volet de Cargo, l’on note quelques nouvelles mises à jour comme la commande cargo init qui peut être utilisée pour démarrer un projet Cargo dans le répertoire en cours d’utilisation au lieu de créer un nouveau sous-répertoire. Pour récupérer des données concernant un projet, les développeurs peuvent utiliser la nouvelle sous-commande cargo metadata. Enfin, les utilisateurs de Cargo peuvent configurer l’outil en mode verbeux ou mettre la couleur en mode automatique en utilisant les nouvelles options -v et --color.

En dehors de ces points, il faut retenir également dans cette nouvelle version que 1400 correctifs ont été appliqués et environ une vingtaine de méthodes et fonctions de bibliothèques ont été rendues stables.

Notes de version

Source : Blog Rust

Et vous ?

Que pensez-vous des nouvelles fonctionnalités de Rust ?

Quelles sont les fonctionnalités que vous souhaiteriez voir dans les prochaines versions ?

Voir aussi

Forum Autres langages
Avatar de Uther
Expert éminent sénior https://www.developpez.com
Le 17/04/2016 à 9:49
Citation Envoyé par Olivier Famien Voir le message
Toujours à propos des nouveautés de cette nouvelle version de Rust, l’équipe de Rust informe que des travaux sont en cours afin de mettre sur pied un nouvel outil pour construire les fichiers Rust. Depuis toujours, Make a été l’outil privilégié pour construire les programmes et bibliothèques Rust. Mais avec le succès de Cargo, un nouveau projet écrit avec Rust et basé sur Cargo a vu le jour avec pour objectif de remplacer Make dans la construction des fichiers et programmes Rust.

Abordant le volet de Cargo, l’on note quelques nouvelles mises à jour comme la commande cargo init qui peut être utilisée pour démarrer un projet Cargo dans le répertoire en cours d’utilisation au lieu de créer un nouveau sous-répertoire. Pour récupérer des données concernant un projet, les développeurs peuvent utiliser la nouvelle sous-commande cargo metadata. Enfin, les utilisateurs de Cargo peuvent configurer l’outil en mode verbeux ou mettre la couleur en mode automatique en utilisant les nouvelles options -v et --color.
Ce point de l'article est très confus.

L'outil standard pour construire les projets en Rust existe déjà et marche très bien : c'est Cargo et il était déjà disponible quelque mois avant la sortie de la version 1.0 de Rust. Depuis que Rust est officiellement disponible, Cargo a toujours été l'outil privilégié pour construire et gérer les dépendances des applications et des bibliothèques écrites en Rust.

Le problème est juste au niveau de la compilation du compilateur Rust lui même. Il a été réécrit en Rust (la première version était en OCaml), des années avant l'arrivée de Cargo, le système de construction a donc été basé sur les makefiles. Le compilateur étant assez complexe, l'adapter pour utiliser Cargo est un très gros travail qui n'était pas considéré comme prioritaire et n'a donc réellement commencé que récemment. Il n'y a pas de nouvel outil : Il s'agit juste de mettre a jour le compilateur pour utiliser l'outil standard que quasiment tous les autres projets Rust utilisent déjà.
Avatar de Olivier Famien
Chroniqueur Actualités https://www.developpez.com
Le 28/11/2016 à 1:34
Rust 1.13.0 est disponible,
avec des optimisations du compilateur et un nouvel opérateur « ? » pour mieux gérer les exceptions

Rust, le langage de programmation multi-paradigme soutenu par la fondation Mozilla est disponible en version 1.13.0. Dans cette nouvelle version, l’on note l’arrivée tant attendue de l’opérateur ?. Avec cet opérateur, il est plus facile et élégant de gérer les erreurs. En guise d’illustration, l’équipe de Rust propose une comparaison entre un bloc de code sans le nouvel opérateur et un second bloc de code avec le nouvel opérateur ?.

Code Rust : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
fn read_username_from_file() -> Result<String, io::Error> { 
    let f = File::open("username.txt"); 
    let mut f = match f { 
        Ok(file) => file, 
        Err(e) => return Err(e), 
    }; 
    let mut s = String::new(); 
    match f.read_to_string(&mut s) { 
        Ok(_) => Ok(s), 
        Err(e) => Err(e), 
    } 
}
Un bloc de code sans le nouvel opérateur ?

Dans le bloc de code ci-dessus, on a deux erreurs qui peuvent se produire. En lisant le fichier et en ouvrant ce dernier. Pour retourner une erreur à partir de la fonction read_username_from_file, il faut utiliser le mot clé match pour associer les différentes opérations aux résultats. Bien que le résultat puisse paraître satisfaisant pour certains, l’équipe de Rust montre qu’avec le nouvel opérateur ?, le code s’avère plus concis.

Code Rust : Sélectionner tout
1
2
3
4
5
6
fn read_username_from_file() -> Result<String, io::Error> { 
    let mut f = File::open("username.txt")?; 
    let mut s = String::new(); 
    f.read_to_string(&mut s)?; 
    Ok(s) 
}
Un bloc de code avec le nouvel opérateur ?

Comme on le constate ci-dessus, avec le nouvel opérateur, on n’a plus besoin de faire correspondre les différentes opérations aux résultats en utilisant le mot clé match qui peut être perçu comme Switch qui est utilisé dans le langage C. En mettant ? devant les différents cas, l’opérateur retourne la valeur du résultat si c’est OK ou sinon retourne une erreur.

Pour certains développeurs, ce nouvel opérateur pourrait ne rien apporter de nouveau, car il n'est en rien différent de la macro try!. Face à ces arguments, l’équipe de Rust rétorque dans certains cas, le code avec ? s’avère plus élégant expose moins à des erreurs qu’en utilisant try!. Par exemple, des deux blocs de code ci-dessous, celui avec l’opérateur ? est plus facile à lire que le code avec try!.

Code Rust : Sélectionner tout
1
2
3
foo()?.bar()?.baz()? // Code avec ? plus lisible 
  
try!(try!(try!(foo()).bar()).baz()) // Code avec try! Moins lisible

À côté de l’apparition de ce nouvel opérateur, nous avons des optimisations au niveau du compilateur. Par exemple, pendant la génération du code LLVM IR, le compilateur ne retraite plus les instances des types associés à chaque fois qu’elles sont demandées, mais réutilise les valeurs précédemment calculées. En outre, nous avons une autre optimisation qui affecte positivement les performances du temps de compilation. Cette optimisation se situe au niveau des crates qui exportent plusieurs fonctions qui sont dotées du mot clé inline. Nous rappelons qu’un crate est une unité de compilation en Rust. Il s’apparente aux bibliothèques ou aux packages dans les autres langages.

Aussi, lorsqu’une fonction est #[inline], le compilateur stocke sa représentation MIR (mid-level IR) dans le crate rlib, qui est une bibliothèque statique régulière contenant des métadonnées supplémentaires. Ensuite, il traduit la fonction en code LLVM IR dans chaque crate qui l'appelle. Cette implémentation permet de soulager le compilateur de convertir les fonctions avec le paramètre inline en code LLVM IR pour ensuite le convertir en langage machine.

En plus de ces éléments, il faut noter dans la nouvelle mouture de Rust, des mises à jour de sécurité pour Cargo qui s’appuie sur Curl et OpenSSL. Ces deux outils ont été mis à jour par leurs auteurs et l’équipe de Rust a rendu ces nouvelles mises à jour compatibles avec cette version de Rust.

En dehors des éléments cités, nous avons plusieurs stabilisations au niveau du langage et des bibliothèques ainsi que l’ajout de fonctionnalités à Cargo, le gestionnaire de packages Rust.

Source : Rust

Et vous ?

Utilisez-vous Rust ? Que pensez-vous de cette nouvelle version ?

Voir aussi

Forum Rust
Contacter le responsable de la rubrique Accueil

Partenaire : Hébergement Web