URL: https://linuxfr.org/news/sortie-de-la-version-0-1-de-rust Title: Sortie de la version 0.1 de Rust Authors: Bruno Michel claudex et Lucas Bonnet Date: 2012年01月22日T11:50:13+01:00 License: CC By-SA Tags: programmation, langage et rust Score: 36 Mozilla a annoncé le 20 janvier la sortie de la version 0.1 du compilateur pour Rust, sous une [licence de type MIT](https://github.com/mozilla/rust/blob/master/LICENSE.txt). Rust est un langage de programmation système fortement typé. L'accent est mis sur la sûreté des accès mémoire et la concurrence. Il fonctionne actuellement sur les plateformes GNU/Linux, OSX et Windows. Voici un exemple d'_Hello World_ : ```go use std; import std::io; fn main() { for i in [1, 2, 3] { io::println(#fmt("hello %d\n", i)); } } ``` Rust est un langage proche de [Go](http://golang.org/), il partage d'ailleurs une inspiration commune venant de [Newsqueak](http://en.wikipedia.org/wiki/Newsqueak), [Alef](http://fr.wikipedia.org/wiki/Alef_%28langage_de_programmation%29) et [Limbo](http://fr.wikipedia.org/wiki/Limbo_%28langage%29). Toutefois, les développeurs de Rust ont commencé leur travail avant l'annonce de Go et ne sont pas satisfaits par la sémantique adoptée par Go (état partagé mutable, [Ramasse-miettes](http://fr.wikipedia.org/wiki/Ramasse-miettes_%28informatique%29) global, pointeurs NULL, absence de destructeurs). _Plus d'informations en seconde partie._ ---- [Le site officiel de Rust](http://www.rust-lang.org/) [L'annonce de la version 0.1](https://mail.mozilla.org/pipermail/rust-dev/2012-January/001256.html) [Le code source de Rust](https://github.com/mozilla/rust) [Le tutoriel](http://doc.rust-lang.org/doc/tutorial.html) ---- Syntaxe ------- Rust est un langage dont la syntaxe peut faire penser au C. Mais Rust n'est pas juste une évolution du C, sa sémantique est réellement différente sur de nombreux aspects. Notons quelques différences avec le C : les types viennent après l'identifiant, les parenthèses sont optionnelles pour les conditions des `if`, `while` et `for`, et tout ce qui n'est pas une déclaration est une expression : ```go // is_four est une fonction qui prend un entier et renvoie un booléen fn is_four(x: int) -> bool { x == 4 } // On peut assigner le retour d'if à une variable car c'est une expression let x = if the_stars_align() { 4 } else if something_else() { 3 } else { 0 }; ``` Chaînes de caractères --------------------- Par défaut, les chaînes de caractères sont en UTF-8. Et de manière très traditionnelle, elles s'écrivent avec des guillemets doubles : ```go let s = "Une chaîne"; ``` Typage ------ Il y aurait beaucoup à dire sur le typage dans Rust. Je vous invite donc à consulter le tutoriel à ce sujet. Je vais essayer de juste présenter l'essentiel. Le typage est statique. Les types de base sont `()` (avec juste la valeur nulle), `bool` (deux valeurs possibles : `true` et `false`), les entiers (`int`, `uint`, etc.) les flotants (`float`, `f32`, `f64`), les caractères (`char`) et les chaînes (`str`). Ces types de base peuvent ensuite être composés dans des types composites : vecteurs (`[T]`), vecteurs mutables (`[mutable T]`), tuples (`(T1, T2)`), enregistrements (`{field1: T1, field2: T2}`), fonctions (`fn(arg1: T1, arg2: T2) -> T3`) et pointeurs (`@T, ~T, *T`). Il est également possible de créer de nouveau type avec le mot-clé `type` : ```go type monster_size = uint; ``` Les variables locales bénéficient de l'inférence de types (leur type peut être omis, le compilateur saura le déduire) : ```go // Le compilateur saura deviner le type de ce vecteur let x = []; // On peut aussi être explicite let y: [int] = []; ``` Rust possède également la notion de types génériques : ```go fn map(v: [T], f: fn(T) -> U) -> [U] { let acc = []; for elt in v { acc += [f(elt)]; } ret acc; } ``` Pattern Matching ---------------- Juste pour le plaisir, un petit exemple de pattern matching : ```go alt my_number { 0 { std::io::println("zero"); } 1 | 2 { std::io::println("one or two"); } 3 to 10 { std::io::println("three to ten"); } _ { std::io::println("something else"); } } ``` Modules ------- L'espace de noms de Rust est séparé en modules. Chaque fichier source commence son propre module. Il est aussi possible d'avoir des modules locaux. Interfaces ---------- Les interfaces sont le moyen de faire le polymorphisme en Rust. Elles se déclarent avec le mot-clé `iface` et les implémentations avec `impl` : ```go iface to_str { fn to_str() -> str; } impl of to_str for int { fn to_str() -> str { int::to_str(self, 10u) } } impl of to_str for str { fn to_str() -> str { self } } ``` Tâches ------ L'approche utilisée pour la concurrence en Rust est les tâches (`tasks`) et est similaire à de nombreux systèmes d'acteurs. Les tâches se lancent avec `spawn`, ne partagent aucune donnée et communiquent entre elles via des ports et canaux : ```go let port = comm::port::(); let chan = comm::chan::(port); let child_task = task::spawn {|| let result = some_expensive_computation(); comm::send(chan, result); }; some_other_expensive_computation(); let result = comm::recv(port); ``` Tests ----- Rust permet d'écrire des tests directement dans le code, en les annotant avec `#[test]` : ```go use std; fn twice(x: int) -> int { x + x } #[test] fn test_twice() { let i = -100; while i < 100 { assert twice(i) == 2 * i; i += 1; } } ``` Ramasse-miettes --------------- La mémoire est libérée à l'aide d'un ramasse-miettes. Celui-ci est capable de travailler sur une seule tâche à la fois, évitant le problème du « bloquer le monde » pendant qu'il se lance.

AltStyle によって変換されたページ (->オリジナル) /