La version stable de Rust 1.25 est maintenant disponible
La version 1.25 de Rust est désormais disponible,
et apporte, avec elle, stabilisation et réorganisation dans l'écosystème du langage
Comme l'équipe Rust a pu le communiquer à travers le post original, cette version n'apporte pas d'ajouts majeurs, mais vient plutôt consolider, et améliorer, ce qui a été précédemment implémenté.
Mise à niveau de LLVM
Les outils du compilateur de Rust fonctionnaient, jusqu'ici, avec LLVM 4. Cette version supportait déjà les microcontrôleurs AVR, mais disposait de nombreux bogues, un passage à LLVM 6 rectifie donc le tir pour Rust.
Ajout: imports imbriqués
Jusqu'à présent, lorsque nous souhaitons importer plusieurs composants provenant d'un même module, il est courant d'écrire ceci:
Code:
use std::path::{Path, PathBuf};
Ou encore, lorsque nous souhaitons importer plusieurs composants provenant de modules différents:
Code:
1
2
3
4
|
use std::fs::File;
use std::io::Read;
use std::path::{Path, PathBuf}; |
Désormais, ça ne sera plus nécessaire. La 1.25 permet l'importation imbriquée lorsque plusieurs sous-modules partagent un même module parent/racine.
(Exemple provenant du post original)
Code:
1
2
3
4
5
6
7
8
9
10
11
12
| // Exemple "inline"
use std::{fs::File, io::Read, path::{Path, PathBuf}};
// Équivalent à la ligne du dessus.
use std::{
fs::File,
io::Read,
path::{
Path,
PathBuf
}
}; |
Documentation et Markdown
Du côté de la documentation, le livre Rust by Example est officiellement publié sur doc.rust-lang.org. En conséquence, vous pourrez obtenir une version offline du livre, comme toutes les autres ressources officielles.
Pour ce qui est de rustdoc, l'équipe Rust annonce que les dernières lignes de code écrites en C se trouvant encore dans l'outil ne sont plus, tandis qu'en parallèle ce dernier s'accorde également avec les spécifications CommonMark pour le parsing du markdown.
Ajout: gestion de l'alignement mémoire
La 1.18 apportait une solution automatique pour optimiser les accès en mémoire mais qui, toutefois, pouvait avoir un coût en ressources plus ou moins important en fonction des besoins. La 1.25 permet de configurer le coût de la compensation en utilisant l'attribut #[repr(align(x))].
(Exemple provenant du post original)
Code:
1
2
3
4
5
6
7
8
9
10
| struct Number(i32);
assert_eq!(std::mem::align_of::<Number>(), 4);
assert_eq!(std::mem::size_of::<Number>(), 4);
#[repr(align(16))]
struct Align16(i32);
assert_eq!(std::mem::align_of::<Align16>(), 16);
assert_eq!(std::mem::size_of::<Align16>(), 16); |
Stabilisation de la std
Concernant la bibliothèque standard, une nouvelle structure, dédiée à la gestion des pointeurs, a été ajoutée : std::ptr::NonNull<T>. Elle permet la gestion de pointeurs mutables tout en offrant la garantie que le pointeur soumis n'est jamais nul.
Par ailleurs, son utilisation est vivement recommandée lorsque du code source Rust communique avec du code étranger (ou "unsafe").
Ajoutons à cela que les méthodes from_secs et from_millis ont vu leur signature changer pour pouvoir être utilisée lors de la définition de constantes.
Code:
1
2
3
4
5
6
7
8
9
10
11
12
| // Exemple d'utilisation pour les deux fonctionnalités présentées.
use std::{
time::Duration,
ptr::NonNull
};
const A_DURATION: Duration = Duration::from_secs(20);
fn main() {
let mutable_integer: NonNull<u8> = NonNull::new(0 as *mut u8).expect("The pointer is null.");
} |
Du nouveau pour Cargo
Nous terminerons sur les petites modifications de comportement apportées aux commandes cargo new et cargo doc.
Pour la première, cargo new générera, désormais, un projet exécutable par défaut. Ajoutons à cela que la commande ne renommera plus les projets préfixés par rust- et/ou suffixés par rs-, après un retour de la communauté sur le sujet.
Pour la seconde, cargo doc bénéficie d'un gain de performance non négligeable. Au lieu de recompiler systématiquement les sources, la commande ne collectera, désormais, plus que les métadonnées nécessaires à la génération de la documentation, réduisant ainsi le temps de traitement.
Source : Annonce officielle
Et vous ?
:fleche: Que pensez-vous de cette nouvelle version ?
:fleche: Quelles sont les améliorations auxquelles vous vous attendiez ?
Voir aussi
:fleche: La version stable de Rust 1.24 est disponible
:fleche: Rust 1.18 est disponible en version stable
1 pièce(s) jointe(s)
L'équipe du langage de programmation Rust annonce la sortie de la version 1.26.0
La version stable de Rust 1.26 est maintenant disponible,
et est probablement la version la plus riche en termes de fonctionnalités depuis Rust 1.0
L'équipe de Rust a annoncé la sortie de la version 1.26.0 du langage de programmation Rust. Pour rappel, ce dernier est un langage de programmation système ultra-rapide, qui prévient les erreurs de segmentation et garantit la sûreté entre threads. Pendant près de 18 mois, Carol, Steve et d'autres ont travaillé sur la réécriture complète de « The Rust Programming Language ». Depuis la version 1.0 du langage de programmation, la version 1.26 est la version stable la plus riche en fonctionnalités d'après les développeurs de Rust. Les autres ayant reçu que quelques changements mineurs.
Si vous avez une version antérieure de Rust installée via rustup, pour obtenir Rust 1.26.0, vous pouvez exécuter cette commande : $ rustup update stable. Mais, si vous ne l'avez pas encore installé, vous pouvez l'obtenir ici.
Qu'est-ce qu'il y a de nouveau avec la version 1.26.0 du langage Rust ?
L'ajout de la fonctionnalité impl Trait qui a longtemps été réclamée par la communauté des développeurs Rust, car elle fournit une fonctionnalité connue sous le nom de « types existentiels ».
Code:
fn foo () -> impl Trait { // ... }
Pour rendre la syntaxe un peu plus symétrique, vous pouvez utiliser impl Trait en position d'argument.
Code:
1
2
3
4
5
|
// before
fn foo < T : Trait > ( x : T ) {
// after
fn foo ( x : impl Trait ) { |
L'équipe Rust a aussi apporté des améliorations à la fonctionnalité match. Elle était au préalable utilisée comme ci-dessous :
Code:
1
2
3
4
5
6
7
|
fn hello(arg: &Option<String>) {
match arg {
&Some(name) => println!("Hello {}!", name),
&None => println!("I don't know who you are."),
}
} |
mais ne marchait pas sur Rust 1.25.0. Le message d'erreur ci-après apparaissait :
Code:
1
2
3
4
5
6
7
8
9
|
error[E0507]: cannot move out of borrowed content
--> src/main.rs:6:9
|
6 | &Some(name) => println!("Hello {}!", name),
| ^^^^^^----^
| | |
| | hint: to prevent move, use `ref name` or `ref mut name`
| cannot move out of borrowed content |
Ils ont apporté des améliorations en ajoutant ref devant name pour obtenir une référence à l'intérieur de l'option.
Code:
1
2
3
4
5
6
7
|
fn hello(arg: &Option<String>) {
match arg {
&Some(ref name) => println!("Hello {}!", name),
&None => println!("I don't know who you are."),
}
} |
Néanmoins, pour la version 1.26 de Rust, la fonctionnalité match sera maintenant utilisée comme l'indique le code suivant :
Code:
match arg { Some ( name ) => println! ( "Hello {}!" , name ),
Le code sera sans & et ref, mais compilera et fera exactement ce que nous attendons. Le compilateur référencera ou dé-référencera automatiquement dans les instructions de match.
Dans Rust 1.26, il sera maintenant possible de déclarer la fonction main qui renvoie Result :
Code:
1
2
3
4
5
6
|
use std::fs::File;
fn main() -> Result<(), std::io::Error> {
let f = File::open("bar.txt")?;
Ok(())
} |
Si la fonction main renvoie une erreur, elle se termine avec un code d'erreur et imprime une représentation de débogage de l'erreur.
Dans Rust 1.26, vous pouvez maintenant créer une plage inclusive, comme ceci :
Code:
1
2
3
4
|
for i in 1. .= 3 {
println! ( "i: {}" , i );
} |
Cela va imprimer i: 1 et ensuite i: 2 comme avant, mais aussi i: 3 ; les trois sont inclus dans la gamme. Les plages inclusives sont particulièrement utiles si nous souhaitons parcourir toutes les valeurs possibles dans une plage.
Dans Rust 1.0, nous avions été en mesure de créer des gammes exclusives avec . . comme ceci :
Code:
1
2
3
4
|
for i in 1. .= 3 {
println! ( "i: {}" , i );
} |
Qui imprimait i: 1 puis i: 2.
L'équipe du langage de programmation Rust dit avoir également stabilisé la bibliothèque fs::read_to_string, une commodité sur File::open et io::Read::read_to_string pour lire facilement un fichier entier en mémoire à la fois :
Code:
1
2
3
4
|
use std :: fs;
use std :: net :: SocketAddr;
let foo : SocketAddr = fs :: read_to_string ( "address.txt" )?.parse ()?; |
Vous pouvez maintenant mettre en forme des nombres au format hexadécimal avec le formatage Debug :
Code:
assert! ( format! ( "{:02x?}" , b "Foo\0" ) == "[46, 6f, 6f, 00]" )
Les virgules de fin sont maintenant supportées par toutes les macros de la bibliothèque standard.
Source : Rust
Et vous ?
:fleche: Qu'en pensez-vous ?
:fleche: Quelle nouveauté appréciez-vous le plus ?
Voir aussi :
:fleche: La version 1.25 de Rust est désormais disponible, et apporte avec elle stabilisation et réorganisation dans l'écosystème du langage
:fleche: Rust : apprendre à encoder et décoder du TOML avec la bibliothèque toml-rs, un tutoriel d'Anthony Defranceschi
:fleche: La version stable de Rust 1.24 est disponible, avec la compilation incrémentielle par défaut pour améliorer le temps de compilation des projets
match avec des retours à la ligne
Est-ce possible de mettre des retours à la ligne sur les exemples de match ?
à la lecture c'est bof (et non conventionnel) et en plus ça nécessite de scroller horizontalement.
La version stable de Rust 1.26.1 est désormais disponible !
La version stable de Rust 1.26.1 est désormais disponible !
et apporte une bonne dose de correctifs à l'écosystème
Rust est un langage de programmation système axé sur la sécurité, la rapidité et la concurrence.
Pour mettre à jour votre version stable, il suffit d’exécuter la commande habituelle.
$ rustup update stable
Quoi de neuf ?
Dans ce billet nous nous intéresserons à la version 1.26.1 qui, comme pour toutes les versions mineures, vient stabiliser ce qui a été apporté dans les mises à jour précédentes.
RLS n'interfère plus avec les commandes de build
La version de RLS fournie avec la 1.26.0 utilisait le même répertoire de sortie que Cargo en ligne de commande, ce qui occasionnait une recompilation intégrale du projet si vous utilisiez les deux à tour de rôle. Le problème était d’autant plus gênant sous Windows, puisque RLS (ou le compilateur) ne relâchait pas le verrou qu’il avait sur les fichiers à traiter. Le bogue n’a pas encore été fixé, mais ce dernier survient moins souvent grâce à un premier correctif.
Mauvais formatage de rustfmt
Précédemment, rustfmt indentait excessivement les chaînes de caractères littérales multilignes. Ce problème est désormais corrigé.
Renvoyer quelque chose depuis `main` avec `impl Trait` ne fonctionnera plus
Jusqu’ici, le compilateur s’assurait uniquement que les services du trait std::process::Termination étaient implémentés par le type renvoyé. Ce comportement est, désormais, révolu puisque rustc n’acceptera plus que les types concrets en retour, sur la version stable. Quant à l’utilisation de impl Termination, elle n’est, actuellement, autorisée que dans le canal nightly.
Par exemple, ce morceau de code ne fonctionnera plus en 1.26.1:
Code:
fn main() -> impl Copy {}
Le second, en revanche, ne posera aucun problème, puisque la signature de la fonction ne déclare aucun type inconnu par le biais de impl Trait.
Code:
1
2
3
4
|
fn main() -> Result<(), std::io::Error> {
Ok(())
} |
Seuls les types concrets peuvent être déclarés dans la signature (pour le type renvoyé, à bon entendeur).
Le turbofish ne fonctionnera plus pour les arguments typés avec `impl Trait`
En 1.26.0, il était possible de spécifier le type des arguments des méthodes qui utilisaient impl Trait. Cependant, comment le turbofish (::<u32>, en l’occurrence) devrait interagir avec un type qui n’a pas encore été inféré (i.e. impl Trait) ? En réponse à cela, l’utilisation du turbofish a été temporairement prohibée, tant que l’équipe Rust n’a pas trouvé de solution à ce problème de sémantique.
La comparaison des valeurs flottantes et constantes a été revue
La constante std::f64::NAN, lorsque comparée à un autre nombre flottant, était considérée systématiquement supérieure à l’autre opérande, ce qui renvoyait jusqu’ici true. Ce bug a également été corrigé.
D’après l’équipe Rust, bien que cela ait occasionné une modification, il est peu probable que cette dernière ait des conséquences sur le comportement des programmes.
Code:
1
2
3
4
5
6
7
|
use std::f64::NAN;
const FOO: bool = ::std::f64::NAN >= ::std::f64::NAN;
// On 1.26.0
assert_eq!(FOO, true);
// On 1.26.1
assert_eq!(FOO, false); |
rustup devrait désormais accepter les installations partielles
Lors du cycle de développement de la 1.26.0, des changements ont été effectués sur la manière dont la documentation de la bibliothèque standard était générée, stoppant par la même occasion la production de la documentation des composants pour un certain nombre de plateformes. En conséquence, lorsque rustup update était lancée sur ces dernières, rustup refusait d’installer partiellement les composants de la chaîne. Les utilisateurs concernés devront alors exécuter rustup install stable au lieu d’une simple mise à jour avec rustup update pour que rustup ignore la documentation manquante.
Le bug a malheureusement été corrigé trop tard pour que le correctif soit inclut dans la 1.26.0 et a donc été ajouté dans le patch de la 1.26.1.
Code:
1
2
3
4
| $ rustup update
info: syncing channel updates for 'stable-x86_64-unknown-freebsd'
info: latest update on 2018-05-10, rust version 1.26.0 (a77568041 2018-05-07)
error: component 'rust-docs' for 'x86_64-unknown-freebsd' is unavailable for download |
Source : The Rust Programming Language Blog
Et vous ?
:fleche: Que pensez-vous de cette nouvelle version ?
:fleche: Quelles fonctionnalités souhaiteriez-vous voir ?
Voir aussi
:fleche: Tutoriel Rust en bref ! Tour d'horizon sur le langage Rust : usage, outils, IDE
:fleche: La version stable de Rust 1.26 est maintenant disponible, et est probablement la version la plus riche en termes de fonctionnalités depuis Rust 1.0
:fleche: La version 1.25 de Rust est désormais disponible, et apporte avec elle stabilisation et réorganisation dans l'écosystème du langage
La version stable de Rust 1.26.2 est désormais disponible !
La version stable de Rust 1.26.2 est désormais disponible !
et vient stabiliser le fonctionnement du pattern matching
Rust est un langage de programmation système axé sur la sécurité, la rapidité et la concurrence.
Pour mettre à jour votre version stable, il suffit d’exécuter la commande habituelle.
Code:
$ rustup update stable
Si vous ne disposez pas de rustup, vous pouvez en obtenir une copie sur la page de téléchargement du site officiel. N’hésitez pas également à consulter la release note de la 1.26.2 sur GitHub !
Quoi de neuf ?
De nouveaux correctifs ont été apportés, principalement axés sur les expressions (et les vérifications sous-jacentes) permises par le compilateur. Comme pour la 1.26.1, cette mise à jour n’a pour but que de stabiliser les fonctionnalités existantes.
Bogue dans la règle des emprunts mutables
En dehors des blocs unsafe, le compilateur ne permet pas deux accès en écriture sur une même ressource en simultané. Toutefois, un est bogue survenu, suite à un recyclage apporté par la 1.26.0 visant à améliorer l’ergonomie de match, permettant ainsi de casser la règle précédemment citée.
Ici, par exemple, nous disposons de deux accès en écriture sur bar au même moment.
Code:
1
2
3
4
5
6
7
8
| let mut foo = Some("foo".to_string());
let bar = &mut foo;
match bar {
Some(baz) => {
bar.take(); // Should not be permitted, as baz has a unique reference to the bar pointer.
},
None => unreachable!(),
} |
En réponse à cela, la version 1.26.2 vient corriger ce problème. Désormais, la vérification est interrompue et renvoie une erreur lorsque le cas survient.
Code:
1
2
3
4
5
6
7
8
9
10
11
12
| error[E0499]: cannot borrow `*bar` as mutable more than once at a time
--> src/main.rs:6:9
|
5 | Some(baz) => {
| --- first mutable borrow occurs here
6 | bar.take(); // Should not be permitted, as baz has a ...
| ^^^ second mutable borrow occurs here
...
9 | }
| - first borrow ends here
error: aborting due to previous error |
En définitive, l’équipe Rust a pris la décision de publier ce patch le plus rapidement possible pour éviter d’étendre inutilement le laps de temps pendant lequel les compilateurs stables sont affectés par ce bogue.
Source
Le blog de l'équipe Rust
Voir aussi
:fleche: La version stable de Rust 1.26.1 est désormais disponible !
