Le langage Rust
Partie 2 sur 4
4Premiers pas
On installe Rust avec l’outil rustup, qui gère les versions du compilateur. Les projets se créent et se construisent avec Cargo, l’outil officiel qui crée la structure du projet, télécharge les bibliothèques nécessaires, compile, lance les tests et produit la documentation :
cargo new bonjour # crée le dossier du projet cd bonjour cargo run # compile et exécute
Le fichier src/main.rs créé par Cargo contient le programme minimal :
fn main() {
println!("Bonjour, le monde !");
}
fn déclare une fonction ; main est le point de départ du programme. Le point d’exclamation de println! signale une macro, un mécanisme qui génère du code à la compilation, ici pour vérifier que le texte à afficher et ses paramètres correspondent. Le fichier Cargo.toml décrit le projet et ses dépendances, les bibliothèques qu’il utilise, que la communauté appelle des crates (« caisses ») et publie sur le site crates.io.
5Les bases du langage
5.1Variables et types
En Rust, les variables sont immuables par défaut : une fois une valeur donnée, on ne peut plus la changer, sauf à déclarer la variable avec mut. Ce choix oblige à signaler explicitement ce qui change, ce qui rend le code plus facile à comprendre. Les types sont vérifiés à la compilation, mais le compilateur les devine le plus souvent seul ; on parle d’inférence de types (voir les variables et les types).
let age = 30; // entier, immuable let mut total = 0; // modifiable grâce à mut total += age; let pi: f64 = 3.14159; // type indiqué explicitement let initiale = 'R'; // un caractère let actif = true; // un booléen
Les entiers ont une taille précise : i32 est un entier signé sur 32 bits, u8 un entier positif sur 8 bits, de 0 à 255. Pour le texte, Rust distingue String, une chaîne qui possède son contenu et peut grandir, et &str, une vue en lecture sur un texte qui appartient à quelqu’un d’autre. Toutes les chaînes sont en UTF-8, le codage universel des caractères (voir les encodages).
5.2Fonctions, conditions et boucles
Une fonction indique le type de ses paramètres et de son résultat. En Rust, presque tout est une expression qui produit une valeur, y compris un if ; la dernière expression d’un bloc, écrite sans point-virgule, est sa valeur :
fn tarif(age: u32) -> f64 {
if age < 18 { 5.0 } else { 9.5 }
}
for i in 1..=3 { // de 1 à 3 inclus
println!("Billet {i} : {} euros", tarif(15 * i));
}
On dispose aussi de while et de loop, une boucle sans fin dont on sort avec break (voir les conditions et les boucles).
5.3Structures, énumérations et filtrage
Une struct regroupe des données sous un même nom ; une enum décrit une valeur qui peut prendre plusieurs formes, chacune avec ses propres données. L’instruction match examine ces formes une à une, et le compilateur vérifie qu’aucun cas n’a été oublié :
enum Forme {
Cercle(f64),
Rectangle(f64, f64),
}
fn aire(f: &Forme) -> f64 {
match f {
Forme::Cercle(r) => 3.14159 * r * r,
Forme::Rectangle(l, h) => l * h,
}
}
Si l’on ajoute plus tard une forme Triangle, le compilateur signalera toutes les instructions match qui ne la traitent pas : une erreur d’oubli devient impossible.
5.4Pas de valeur nulle : Option
Rust n’a pas de pointeur nul. Une valeur qui peut manquer a le type Option, qui vaut soit Some(valeur), soit None. Le programmeur est obligé de traiter les deux cas avant d’utiliser la valeur : l’oubli, source de millions de plantages dans d’autres langages, est refusé à la compilation.
fn premier_pair(nombres: &[i32]) -> Option<i32> {
for &n in nombres {
if n % 2 == 0 {
return Some(n);
}
}
None
}
match premier_pair(&[3, 7, 10, 4]) {
Some(n) => println!("Premier nombre pair : {n}"),
None => println!("Aucun nombre pair"),
}
5.5Les erreurs : Result
Rust n’a pas d’exceptions au sens de Java ou de Python (voir la gestion des erreurs). Une opération qui peut échouer renvoie un Result, qui vaut soit Ok(valeur), soit Err(erreur). L’opérateur ? transmet l’erreur à la fonction appelante, ce qui garde le code lisible :
use std::fs;
use std::io;
fn lire_config(chemin: &str) -> Result<String, io::Error> {
let texte = fs::read_to_string(chemin)?; // en cas d'erreur, on la renvoie
Ok(texte.trim().to_string())
}
On peut aussi écrire .unwrap(), qui extrait la valeur ou, en cas d’erreur, arrête brutalement le programme : c’est une panique (en anglais panic). Pratique dans un exemple, dangereux dans un service en production, comme le montre le coin cyber.
5.6Traits, généricité et itérateurs
Rust n’a pas de classes ni d’héritage. Les comportements communs sont décrits par des traits, proches des interfaces de Java : un trait déclare des méthodes, et chaque type peut l’implémenter à sa façon. Les fonctions génériques acceptent tout type qui implémente un trait donné, et le compilateur produit pour chaque type une version spécialisée, aussi rapide que du code écrit à la main (voir la programmation orientée objet).
trait Decrire {
fn decrire(&self) -> String;
}
impl Decrire for Forme {
fn decrire(&self) -> String {
format!("une forme d'aire {:.2}", aire(self))
}
}
Les itérateurs permettent d’enchaîner des traitements sur des collections, sans boucle explicite, et les fermetures (en anglais closures) sont de petites fonctions anonymes passées en paramètre :
let notes = vec![12, 7, 15, 9, 18]; let admis: Vec<i32> = notes.iter().filter(|&&n| n >= 10).cloned().collect(); // admis vaut [12, 15, 18]
Ces abstractions sont dites « à coût nul » : une fois compilées, elles sont aussi rapides qu’une boucle écrite à la main.
Pour s’exercer
Exercice 1 : déplacé ou copié ?
Lesquels de ces deux programmes compilent ? Pourquoi ?
// Programme A
let x: i32 = 5;
let y = x;
println!("{x} {y}");
// Programme B
let s1 = String::from("bonjour");
let s2 = s1;
println!("{s1} {s2}");
Voir la réponse
A compile : un i32 est un type simple qui implémente Copy ; y reçoit une copie et x reste utilisable. B ne compile pas : une String possède un contenu dans le tas ; let s2 = s1 déplace la propriété et s1 devient inutilisable. Trois corrections possibles : n’afficher que s2 ; écrire let s2 = s1.clone(); pour obtenir une vraie copie ; ou écrire let s2 = &s1; pour emprunter au lieu de déplacer.
Exercice 2 : la fonction qui garde tout
Ce programme ne compile pas. Corrigez-le sans utiliser clone.
fn saluer(nom: String) {
println!("Bonjour {nom}");
}
let nom = String::from("Inès");
saluer(nom);
println!("Au revoir {nom}");
Voir la réponse
L’appel saluer(nom) déplace la chaîne dans la fonction, qui la détruit à la fin ; la dernière ligne utilise donc une valeur déplacée. La fonction n’a besoin que de lire le nom : il suffit qu’elle l’emprunte. On écrit fn saluer(nom: &str) et on l’appelle avec saluer(&nom). Le type &str est préférable à &String : il accepte aussi bien une String empruntée qu’un texte écrit directement dans le programme.
Exercice 3 : une division sans plantage
Écrivez une fonction diviser(a: f64, b: f64) qui renvoie le quotient, ou aucune valeur si b vaut zéro, puis affichez le résultat de diviser(10.0, 4.0) et de diviser(1.0, 0.0).
Voir la réponse
fn diviser(a: f64, b: f64) -> Option<f64> {
if b == 0.0 { None } else { Some(a / b) }
}
for (a, b) in [(10.0, 4.0), (1.0, 0.0)] {
match diviser(a, b) {
Some(q) => println!("{a} / {b} = {q}"),
None => println!("{a} / {b} : division par zéro"),
}
}
Le type de retour Option<f64> annonce à tout utilisateur de la fonction que le résultat peut manquer, et le compilateur l’oblige à traiter ce cas. Le premier appel affiche 2,5 (écrit 2.5), le second le message d’erreur.
Exercice 4 : propager une erreur
Écrivez une fonction lire_age(texte: &str) qui convertit un texte en entier positif et renvoie une erreur si la conversion échoue. Que se passe-t-il avec "42", "-3" et "quarante" ?
Voir la réponse
use std::num::ParseIntError;
fn lire_age(texte: &str) -> Result<u8, ParseIntError> {
let age = texte.trim().parse::<u8>()?;
Ok(age)
}
"42" donne Ok(42). "-3" et "quarante" donnent une Err : le type u8 n’accepte que des entiers de 0 à 255, et le texte n’est pas un nombre valide pour ce type. L’opérateur ? renvoie l’erreur à l’appelant, qui décidera quoi faire, par exemple afficher un message et redemander la saisie, au lieu d’arrêter le programme.