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.6 est disponible en version stable
La bibliothèque libcore du langage de programmation de Mozilla est maintenant stable

Le , par Michael Guilloux

170PARTAGES

6  0 
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

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

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à.
2  0 
Avatar de Songbird
Membre expert https://www.developpez.com
Le 10/06/2017 à 18:41


Je ne doutes pas que je finirais par en faire,
mais aujourd'hui à cet instant, la chose n'est pas évidente pour moi
et je préfère encore me tourner vers d'autres langages
partageant certains points commun avec celui ci.
Qu'est-ce qui te paraît peu évident ? Tes questions et remarques sont les bienvenues.

Concernant la syntaxe, c'est précisément ce qui me donne envie d'étudier Rust (si l'on ne parle que d'elle), car la syntaxe me semble moins... éparpillée que le C++. Cela reste très personnel, bien entendu.
D'ailleurs, si quelque chose te rebute dans la syntaxe, des ressources existent pour expliquer littéralement ce que signifie telle ou telle expression.

Très bonne journée !
2  0 
Avatar de mh-cbon
Membre extrêmement actif https://www.developpez.com
Le 10/06/2017 à 12:08
Rust c'est tout de même plusieurs choses, amha.

Un langage pour répondre aux problèmes de ces prédécesseurs.
Un toolset autour du langage pour vivre avec.
Un esprit définitivement progressiste et tourné vers l'avenir.

De cet ensemble, je suis très satisfait,
c'est un changement appréciable car il est plus proche des utilisateurs,
en comparaison, pendant longtemps les avancées que l'on pouvait lire à propos des langages
concernaient des questions très théorique de la théorie des langages (preuves formelles etc)
qui finalement aboutissaient à peu de changement concret/applicable pour l'utilisateur final lambda.

J'apprécie beaucoup cela, pour autant est ce que j'aime ce langage,
bein pas trop en fait,
comme tout le monde, j'aime bien sa théorie et sa mise en pratique,
mmmmmeeeeehhhhhh
la syntaxe est bien trop complexe pour mon goût personnel.

Je ne doutes pas que je finirais par en faire,
mais aujourd'hui à cet instant, la chose n'est pas évidente pour moi
et je préfère encore me tourner vers d'autres langages
partageant certains points commun avec celui ci.
1  0 
Avatar de imperio
Membre émérite https://www.developpez.com
Le 10/06/2017 à 13:56
la syntaxe est bien trop complexe pour mon goût personnel.
Ah ? Voilà qui est intéressant ! Venant des langages C/C++, j'ai trouvé la syntaxe de rust nettement plus simple. De quel(s) langage(s) viens-tu du coup ?
1  0 
Avatar de mothsART
Membre régulier https://www.developpez.com
Le 11/06/2017 à 14:13
Mh-cbon : ton approche top => bottom est bonne : beaucoup ne font pas l'effort et du coup progresse peu à mon sens.
Le passage à un typage fort est douloureux mais au final nécessaire car le gain est juste énorme : tu évites une paire de bug à l’exécution, le code est plus cohérent, t'as de meilleurs perfs etc.

Tu mets C et C++ dans le panier des vieux langages mais tu remarqueras que Go ne les remplace pas vraiment car il utilise un Garbage collector et une VM.
Pour moi, Go est un Java bis avec une syntaxe minimaliste, des gros avantages sur la programmation concurrente et des temps de compilation plus court.
Bref, rien de bien novateur à mon sens.

La réalité est que C et C++ sont pour l'instant encore indétrônable dans tous les domaines ou les perfs et la gestion de la mémoire sont critiques.
Rust étant plus ambitieux et par conséquent plus complexe est un réel candidat pour les remplacer.

Je dirais, pour ma part que le cap à passer pour Rust n'était pas vraiment la syntaxe (que je trouve élégante et intuitive) mais plus le borrowing. (et dans une moindre mesure les macros et closures)

Mais, comme tous les langages, il a des zones implicites qui nécessite apprentissage.
Ton exemple et ton incompréhension proviennent de là :

* la variable "f" et "let mut f" : f est dans un premier temps immutable : si le match réussi (passe par le Ok), cette variable est écrasé par le résultat et est converti en une variable mutable.
* le type Result est un peu particulier : il attend soit un objet succès ("Ok" avec le résultat (ici typé en String car on désire récupérer le contenu du fichier mais ça pourrais être n'importe quoi d'autre dans un autre contexte) ou un objet d'échec ("Err".
* le premier match (qui vérifie l'accès en lecture du fichier) a un retour explicite qui précise que si il détecte une erreur, il sort directement de la fonction (et par conséquent la variable mutable f n'est pas alimenté, la variable s n'est pas créé et le dernier match non executé.
* let permet de déclarer une variable, je ne vois pas trop ce qui te choques. (tu remplaces "var" par "let" dans ton passage de Go à Rust ou de NodeJS à Rust)
* en rust si la dernière ligne d'une fonction ne se termine pas par ";", on retourne implicitement le résultat.
C'est ce qui se passe dans le dernier match.
* s n'est pas déclaré 2 fois, elle est passé par référence dans la fonction "read_to_string".
* read_username_from_file renvoi une valeur qui peut parfaitement être mutable ou non selon la déclaration de ta variable de récupération :
Code : Sélectionner tout
1
2
3
4
let username_immutable = read_username_from_file();
// ou
let mut username_mutable = read_username_from_file();
1  0 
Avatar de Uther
Expert éminent sénior https://www.developpez.com
Le 12/06/2017 à 13:18
Citation Envoyé par mh-cbon  Voir le message
Je ne vois pas où est construit le retour Result<...>.

Result est un cas particulier vu que comme c'est un élément central du langage, ses variant OK et Err sont inclus dans le prélude, ce qui fait que l'on peut les utiliser directement. Comme le type Result est utilisé partout, n'importe qui avec un minimum d'expérience dans le langage reconnais ça du premier abord.

Cependant, si tu tient à ce que ce soit clair que Ok et Err sont des variants du type énuméré Result, tu peux faire :
Code Rust : Sélectionner tout
1
2
3
4
    let mut f = match f { 
        Result::Ok(file) => file, 
        Result::Err(e) => return Result::Err(e), 
    };
1  0 
Avatar de Songbird
Membre expert https://www.developpez.com
Le 12/06/2017 à 18:09


Tout comme les variantes de l'enum Option<T>: Some(T) et None sont parfaitement comprises par le compilateur.

Sans expliciter la provenance des variantes ça donne:

Code Rust : Sélectionner tout
1
2
3
4
5
6
7
8
fn main() { 
    let foo = Some("Hello there!".to_owned()); 
    let bar = match foo{ 
        Some(content) => content, 
        None => "Nothing, here.".to_owned(), 
    }; 
    println!("bar={}", &bar); 
}

Ce sont de petites subtilités, mais vraiment rien d'insurmontable. Ce ne sont pas des ressources "magiques", juste des raccourcis.
1  0 
Avatar de tralloc
Membre averti https://www.developpez.com
Le 15/06/2017 à 9:19
@mh-cbon
Eh bien moi c'est la deuxième fois que je me penche sur ce language.la première fois je l'ai trouvé trop complexe moi aussi.
Rien à voir avec les typages forts parce que je fais du JEE du C. Ni les typages faibles, car je ne suis pas trop mauvais en python.
Eh bien pour une deuxième fois, je commence à l'apprécier, et je crois qu'il vaut vraiment le coup.

La syntaxe est une chose, lorsqu'on a commencé à la comprendre il faut ensuite l'adopter. Une fois ce cap passé on peut profiter de sa richesse.
1  0 
Avatar de Kennel sébastien
Membre averti https://www.developpez.com
Le 15/06/2017 à 10:19
Bonjour tralloc,

C'est super de chercher à aider les autres :-).

Je voulais juste me permettre de te signaler un point :-p :
Tu as écrit « Ni les typages faibles, car je ne suis pas trop mauvais en python », or Python a un typage fort, en effet tu confonds typage statique et dynamique mais les trois langages ont des typages fort.

Des langages qui auraient des typages faibles sont par exemple : PHP, Javascript ou Ring.

Code : Sélectionner tout
print(5 + "5")
Ne travaille pas en Python, mais sous Ring avec :
Code : Sélectionner tout
See 5 + "5"
Tu obtiens le résultat 10 !

Rust a en fait un typage qui est inféré comme Go, Crystal, Swift…, c'est-à-dire que tu peux le rendre statique ou le laisser chercher le type pour toi alors que tu pourrais pas le faire en Python, en Python c'est lui qui cherche pour toi, il n'y a pas de déclaration de type.

Enfin pour ceux qui trouvent trop difficile Rust, peut-être vous tournez sur Go et revenir après sur Rust…
1  0 
Avatar de joublie
Membre confirmé https://www.developpez.com
Le 18/03/2017 à 13:41
[B]cargo check[/C]

" Alors concrètement de quel pourcentage de vitesse les développeurs vont-ils bénéficier ? " C'est assez mal rédigé, non ?
0  0