Windows : rustup-init.exe ; il propose d’installer les outils Visual Studio (éditeur de liens MSVC) requis.

Une version stable toutes les 6 semaines ; au 29 septembre 2026 : 1.98. Édition courante : 2024 (depuis Rust 1.85).

// src/main.rs
fn main() {
    let nom = "monde";
    println!("Bonjour, {nom} !");
}

• fn main() : point d’entrée du programme.
• println! : le ! signale une macro.
• Instruction terminée par ; ; blocs entre { }.
• Commentaires : // ligne · /* */ bloc · /// documentation de l’élément qui suit.
• Noms : snake_case variables, fonctions · CamelCase types, traits · MAJUSCULES constantes.

! Réaffecter une liaison sans mut : erreur E0384.

Littéraux

Bornes : i32::MAX, u8::MIN… ! Dépassement d’entier : panique en mode debug, résultat « rebouclé » en --release. Choisir : checked_add (→ Option), wrapping_add, saturating_add.

a[i] hors limites : panique, jamais de lecture hasardeuse. a.get(i) renvoie une Option.

! as tronque : 300_i32 as u8 → 44 ; -1_i32 as u32 → 4294967295 ; 2.9_f64 as i32 → 2 ; 300.0_f64 as u8 → 255.

Macros d’usage courant

1. Lire la première erreur : les suivantes en découlent souvent.
2. Code E0382 → rustc --explain E0382 : explication et exemples.
3. Suivre les lignes help: : le correctif y est souvent proposé.
4. cargo check pour itérer vite ; cargo clippy pour les tournures idiomatiques.

Erreurs d’emprunt : page 3. Hors blocs unsafe, le compilateur écarte des classes entières d’erreurs mémoire : pointeur pendant, double libération, accès concurrent non synchronisé.

Ni ++ ni -- : n += 1. Puissance : 2_i32.pow(10), x.powf(0.5), x.sqrt(). Arrondis : round, floor, ceil · bornes : min, max, clamp · reste positif : rem_euclid (-7 % 3 → -1). ! Flottants : comparer (a - b).abs() < 1e-9, pas a == b après un calcul.

let signe = if n < 0 { "négatif" } else { "positif" };

let carre = {
    let a = 3;
    a * a            // pas de ; : valeur du bloc
};                   // carre = 9

Un bloc vaut sa dernière expression sans ; ; avec ;, il vaut (). Les branches d’un if doivent avoir le même type.

fn aire(l: f64, h: f64) -> f64 {
    l * h                           // valeur renvoyée
}

fn diviser(a: i32, b: i32) -> Option<i32> {
    if b == 0 {
        return None;                // sortie anticipée
    }
    Some(a / b)
}

fn saluer(nom: &str) {              // renvoie ()
    println!("Bonjour {nom}");
}

• Types des paramètres obligatoires ; type de retour après ->.
• Ni paramètres par défaut ni surcharge : Option, noms distincts, constructeurs.
• ! fn f() -> i32 { 5; } : le ; fait renvoyer () → E0308.
• Retour -> ! : la fonction ne revient jamais (panic!, std::process::exit).

let double = |x| x * 2;
let somme = |a: i32, b: i32| -> i32 { a + b };
let seuil = 10;
let grand = |x: &i32| *x > seuil;   // capture seuil
let f = move || println!("{seuil}");// prend possession

move : indispensable quand la fermeture survit à la portée courante (thread, valeur renvoyée). Accepter une fermeture : fn appliquer(f: impl Fn(i32) -> i32).

for i in 0..5 { }                   // 0, 1, 2, 3, 4
for i in 1..=5 { }                  // 1 à 5 inclus
for i in (0..10).rev() { }          // 9 à 0
for i in (0..10).step_by(3) { }     // 0, 3, 6, 9
for (i, x) in v.iter().enumerate() { }

while n > 0 { n -= 1; }

let mut k = 0;
let r = loop {                      // boucle sans fin…
    k += 1;
    if k == 10 { break k * 2; }     // …qui renvoie 20
};

'externe: for x in 0..5 {           // étiquette
    for y in 0..5 {
        if x + y > 6 { break 'externe; }
        if y > x { continue 'externe; }
    }
}

for x in &v parcourt sans consommer ; for x in v consomme v (inutilisable ensuite) ; for x in &mut v permet de modifier : *x += 1.

match n {
    0 => println!("zéro"),
    1 | 2 => println!("un ou deux"),
    3..=9 => println!("chiffre"),
    x if x < 0 => println!("négatif : {x}"),
    grand @ 100.. => println!("grand : {grand}"),
    _ => println!("autre"),
}

let pays = match code {             // une expression
    'F' => "France",
    'D' => "Allemagne",
    _ => "inconnu",
};

! Un match doit être exhaustif : tout cas possible couvert, sinon E0004. _ en dernier recueille le reste.

if let Some(x) = option {           // un seul motif
    println!("{x}");
} else {
    println!("rien");
}

let Some(x) = option else {         // let … else
    return;                         // doit sortir
};                                  // x reste utilisable

while let Some(sommet) = pile.pop() {
    println!("{sommet}");
}

if let Some(x) = option && x > 10 { }   // édition 2024

let voyelle = matches!(c, 'a' | 'e' | 'i' | 'o' | 'u');

Le bloc else d’un let … else doit diverger : return, break, continue, panic!. Chaînes if let … && : édition 2024, Rust 1.88 ou plus.

let s1 = String::from("salut");
let s2 = s1;                        // déplacement
// println!("{s1}");                // E0382 : valeur déplacée

let s3 = s2.clone();                // copie profonde
println!("{s2} {s3}");              // les deux sont valides

let a = 5;
let b = a;                          // i32 est Copy
println!("{a} {b}");                // a reste valide

fn prendre(s: String) { }           // prend possession
prendre(s3);                        // s3 inutilisable ensuite

fn longueur(s: &String) -> usize { s.len() }  // lit
fn crier(s: &mut String) { s.push('!'); }     // modifie

let mut s = String::from("salut");
let n = longueur(&s);               // emprunt partagé
crier(&mut s);                      // emprunt exclusif

let mut v = vec![1, 2, 3];
let premier = &v[0];                // emprunt partagé…
v.push(4);                          // E0502 : exclusif
println!("{premier}");              // …encore utilisé ici

Pourquoi ? push peut réallouer le vecteur : premier désignerait une mémoire libérée. Correctifs : utiliser premier avant le push, ou copier la valeur (let premier = v[0];).

Un emprunt dure jusqu’à sa dernière utilisation, pas jusqu’à la fin du bloc.

fn plus_long<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() >= y.len() { x } else { y }
}

struct Extrait<'a> {
    texte: &'a str,                 // la structure emprunte
}

• 'a ne change aucune durée : il décrit le lien entre les références (ici : le résultat vit autant que la plus courte des deux).
• Élision : une seule référence en paramètre, ou &self → annotation inutile.
• 'static : valable pendant tout le programme (littéraux "…").

{
    let a = String::from("a");
    let b = vec![1, 2, 3];
    // … a et b utilisables ici
}                       // fin de portée : b, puis a, libérés
let v = vec![0; 1000];
drop(v);                // libération anticipée

Ordre inverse de la déclaration. impl Drop : agir à la libération (fermer un fichier, relâcher un verrou).

Renvoyer une valeur possédée (String, Vec<T>) plutôt qu’une référence vers une variable locale.

Associations classiques : Rc<RefCell<T>> (un thread) · Arc<Mutex<T>> (plusieurs threads).

! RefCell : deux borrow_mut() simultanés → panique. Deux Rc qui se désignent mutuellement ne sont jamais libérés : fuite mémoire (utiliser Weak).

Détail et exemples : rustc --explain code ou doc.rust-lang.org/error_codes.

#[derive(Debug, Clone, PartialEq)]
struct Point {
    x: f64,
    y: f64,
}

impl Point {
    fn new(x: f64, y: f64) -> Self { // fonction associée
        Self { x, y }                // raccourci de x: x
    }
    fn norme(&self) -> f64 { self.x.hypot(self.y) }
    fn deplacer(&mut self, dx: f64) { self.x += dx; }
    fn eclater(self) -> (f64, f64) { (self.x, self.y) }
}

let mut p = Point::new(3.0, 4.0);
println!("{}", p.norme());           // 5
p.deplacer(1.0);
let q = Point { y: 0.0, ..p.clone() }; // autres champs de p
let Point { x, y } = q;              // déstructurer

use std::f64::consts::PI;

enum Forme {
    Cercle { rayon: f64 },
    Rectangle(f64, f64),
    Point,
}

impl Forme {
    fn aire(&self) -> f64 {
        match self {
            Forme::Cercle { rayon } => PI * rayon * rayon,
            Forme::Rectangle(l, h) => l * h,
            Forme::Point => 0.0,
        }
    }
}

Une valeur d’énumération est une de ses variantes, chacune avec ses propres données : idéal pour modéliser des états.

Dans le prélude, sans use : enum Option<T> { None, Some(T) } et enum Result<T, E> { Ok(T), Err(E) }. Rust n’a pas de null.

trait Decrire {
    fn nom(&self) -> String;         // à fournir
    fn decrire(&self) -> String {    // fournie par défaut
        format!("Je suis {}", self.nom())
    }
}

impl Decrire for Point {
    fn nom(&self) -> String { "un point".to_string() }
}

use std::fmt;
impl fmt::Display for Point {        // active {} et to_string
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

Implémenter un trait pour un type : permis si le trait ou le type est défini dans votre crate (règle de l’orphelin).

fn plus_grand<T: PartialOrd>(v: &[T]) -> &T {
    let mut max = &v[0];
    for x in v {
        if x > max { max = x; }
    }
    max
}

fn afficher(x: impl fmt::Display) { println!("{x}"); }

fn resumer<T>(x: &T) -> String
where
    T: Decrire + Clone,
{
    x.decrire()
}

struct Pile<T> { elements: Vec<T> }
impl<T> Pile<T> {
    fn empiler(&mut self, x: T) { self.elements.push(x); }
}

Générique : une copie du code par type, à la compilation (monomorphisation) — rapide. dyn : un seul code, appel indirect ; permet les collections hétérogènes : Vec<Box<dyn Decrire>>.

! f64 n’implémente ni Eq ni Ord (à cause de NaN) : v.sort_by(|a, b| a.total_cmp(b)).

! Un pub struct garde ses champs privés : mettre pub devant chaque champ voulu.

Ni exceptions ni null : les échecs possibles se lisent dans la signature des fonctions.

• Oui : bogue, invariant impossible, tests, prototypes ; expect sur une hypothèse démontrée.
• Non : tout ce qui vient de l’extérieur (fichier, saisie, réseau, données).
• Paniques implicites : index hors limites, division entière par zéro, dépassement (debug), unwrap sur None / Err, tranche de str coupant un caractère.
• Voir la pile d’appels : variable d’environnement RUST_BACKTRACE=1.

use std::error::Error;
use std::fs;

fn lire_nombre(chemin: &str) -> Result<i64, Box<dyn Error>> {
    let texte = fs::read_to_string(chemin)?;  // io::Error
    let n: i64 = texte.trim().parse()?;       // ParseIntError
    Ok(n * 2)
}

fn main() -> Result<(), Box<dyn Error>> {
    let n = lire_nombre("nombre.txt")?;
    println!("{n}");
    Ok(())
}

• x? : si Ok(v), donne v ; si Err(e), renvoie aussitôt Err(e.into()).
• Fonctionne aussi sur Option dans une fonction qui renvoie Option.
• Seulement dans une fonction qui renvoie Result ou Option (sinon E0277).
• main peut renvoyer Result : une erreur y est affichée (format Debug) et le programme se termine avec un code d’échec.

Une suite de Result → un seul : .collect::<Result<Vec<_>, _>>() (arrêt à la première erreur).

use std::{fmt, io};

#[derive(Debug)]
enum ErreurConfig {
    Absente(String),
    Syntaxe(usize),
    Io(io::Error),
}

impl fmt::Display for ErreurConfig {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::Absente(c) => write!(f, "clé {c} absente"),
            Self::Syntaxe(n) => write!(f, "erreur ligne {n}"),
            Self::Io(e) => write!(f, "entrée-sortie : {e}"),
        }
    }
}

impl std::error::Error for ErreurConfig {}

impl From<io::Error> for ErreurConfig {  // pour ?
    fn from(e: io::Error) -> Self { Self::Io(e) }
}

• Bibliothèque : type d’erreur précis (enum), pour que l’appelant distingue les cas.
• Application : Box<dyn Error> suffit souvent.
• Crates tierces répandues : thiserror (écrit ce code) et anyhow (erreurs d’application, contexte) — à évaluer comme tout code externe.

use std::fs::File;
use std::io::{self, BufRead, BufReader, Write};

for ligne in BufReader::new(File::open("a.txt")?).lines() {
    let ligne = ligne?;              // chaque ligne : Result
    println!("{ligne}");
}
let mut sortie = File::create("rapport.txt")?;
writeln!(sortie, "total : {}", 42)?;

Lire le clavier

print!("Votre âge : ");
io::stdout().flush()?;               // afficher aussitôt
let mut saisie = String::new();
io::stdin().read_line(&mut saisie)?;
let age: u32 = saisie.trim().parse()?; // trim : retire \n

write!, writeln! et flush exigent le trait Write : use std::io::Write.

! s[0] est refusé : en UTF-8, un caractère occupe de 1 à 4 octets. Premiers caractères : s.chars().take(n).collect::<String>().

Clés Hash… : Eq + Hash ; clés BTree… : Ord.

use std::collections::HashMap;

let mut notes: HashMap<String, u32> = HashMap::new();
notes.insert("Anne".to_string(), 15);
if let Some(n) = notes.get("Anne") { println!("{n}"); }

let mut compte = HashMap::new();     // compter les mots
for mot in texte.split_whitespace() {
    *compte.entry(mot).or_insert(0) += 1;
}
for (cle, val) in &notes { println!("{cle} : {val}"); }

! Ordre de parcours imprévisible, variable d’une exécution à l’autre : BTreeMap, ou trier, si l’ordre compte.

struct Compte { n: u32 }
impl Iterator for Compte {
    type Item = u32;                 // type produit
    fn next(&mut self) -> Option<u32> {
        self.n += 1;
        if self.n <= 3 { Some(self.n) } else { None }
    }
}
// Compte { n: 0 }.collect::<Vec<_>>() → [1, 2, 3]

Seul next est à écrire : map, filter, sum… sont fournis par le trait.

let v = vec![3, 1, 4, 1, 5, 9, 2, 6];
let doubles: Vec<i32> = v.iter()
    .filter(|x| *x % 2 == 0)         // 4, 2, 6
    .map(|x| x * 2)
    .collect();                      // [8, 4, 12]
let total: i32 = v.iter().sum();     // 31

! Paresseux : sans consommateur (collect, sum, for…), rien n’est calculé.

mon_projet/
+-- Cargo.toml       manifeste : nom, dépendances
+-- Cargo.lock       versions exactes retenues (généré)
+-- src/
|   +-- main.rs      exécutable : fn main
|   +-- lib.rs       bibliothèque (facultatif)
|   +-- config.rs    module config
|   +-- reseau.rs    module reseau…
|   +-- reseau/
|       +-- client.rs  sous-module reseau::client
+-- tests/           tests d'intégration
+-- examples/        cargo run --example nom
+-- benches/         mesures de performance
+-- target/          produits de compilation (hors Git)

[package]
name = "mon_projet"
version = "0.1.0"
edition = "2024"

[dependencies]
regex = "1"                      # >= 1.0.0 et < 2.0.0
serde = { version = "1", features = ["derive"] }
outil = { path = "../outil" }    # dépendance locale

[dev-dependencies]               # pour les tests seulement
proptest = "1"

[profile.release]
lto = true                       # optimisation plus poussée

Versions : "1.2" accepte toute version compatible (≥ 1.2.0 et < 2.0.0) ; "=1.2.3" : cette version exacte.

! Une dépendance est du code tiers, exécuté dès la compilation (build.rs, macros) : vérifier auteur, licence, activité, avis de sécurité (rustsec.org ; outil tiers cargo audit).

// src/main.rs
mod geometrie;                   // charge src/geometrie.rs
use geometrie::{distance, Point};
use std::io::{self, Write};      // io et io::Write

// src/geometrie.rs
pub struct Point { pub x: f64, pub y: f64 }

pub fn distance(a: &Point, b: &Point) -> f64 {
    (a.x - b.x).hypot(a.y - b.y)
}

Crate : unité de compilation (un exécutable ou une bibliothèque). Paquet (package) : un Cargo.toml et ses crates.

pub fn diviser(a: i32, b: i32) -> i32 {
    if b == 0 { panic!("division par zéro"); }
    a / b
}

#[cfg(test)]                     // compilé pour cargo test
mod tests {
    use super::*;

    #[test]
    fn quotient() {
        assert_eq!(diviser(7, 2), 3);
        assert!(diviser(-6, 3) < 0, "négatif attendu");
    }

    #[test]
    #[should_panic(expected = "division par zéro")]
    fn par_zero() { diviser(1, 0); }

    #[test]
    fn lecture() -> Result<(), std::num::ParseIntError> {
        assert_eq!("42".parse::<i32>()?, 42);
        Ok(())
    }
}

/// Moyenne d'une tranche ; `None` si elle est vide.
///
/// ```
/// assert_eq!(mon_projet::moyenne(&[2.0, 4.0]), Some(3.0));
/// ```
pub fn moyenne(v: &[f64]) -> Option<f64> {
    if v.is_empty() { return None; }
    Some(v.iter().sum::<f64>() / v.len() as f64)
}

/// documente l’élément suivant (Markdown) ; //! le module entier. Les blocs de code de la documentation sont exécutés par cargo test (bibliothèques).

use std::sync::{mpsc, Arc, Mutex};
use std::thread;

let h = thread::spawn(|| 6 * 7);
let r = h.join().unwrap();           // 42

let compteur = Arc::new(Mutex::new(0));
let mut poignees = vec![];
for _ in 0..4 {
    let c = Arc::clone(&compteur);
    poignees.push(thread::spawn(move || {
        *c.lock().unwrap() += 1;
    }));
}
for p in poignees { p.join().unwrap(); }
// *compteur.lock().unwrap() vaut 4

let (tx, rx) = mpsc::channel();      // canal
thread::spawn(move || tx.send("message").unwrap());
println!("{}", rx.recv().unwrap());

let v = vec![1, 2, 3];
thread::scope(|s| {                  // threads bornés :
    s.spawn(|| println!("{v:?}"));   // emprunt permis
});

• Send : transférable à un autre thread · Sync : partageable par référence. Rc ou RefCell entre threads : refusé (E0277).
• lock() renvoie Err si un thread a paniqué en tenant le verrou (verrou « empoisonné »).
• ! Le verrou reste pris jusqu’à la fin de la portée du garde : sections courtes. Deux verrous pris dans des ordres différents → interblocage, que le compilateur ne détecte pas.

• async fn renvoie un futur : rien ne s’exécute avant .await.
• La bibliothèque standard ne fournit pas d’exécuteur : il vient d’une crate tierce, le plus souvent tokio.
• Pour de nombreuses attentes d’entrées-sorties (réseau, serveurs). Pour du calcul : threads.

#[tokio::main]
async fn main() {
    let (a, b) = tokio::join!(tache_a(), tache_b());
}

macro_rules! carre {
    ($x:expr) => { $x * $x };
}
let n = carre!(3 + 1);           // 16 : $x reste groupé

Un bloc unsafe { } autorise cinq opérations invérifiables : déréférencer un pointeur brut, appeler une fonction unsafe (dont le code C), lire ou modifier un static mut, implémenter un trait unsafe, lire un champ d’union. Les autres règles restent actives. Un programme d’application n’en a presque jamais besoin.

• Constructeur new() et impl Default ; impl From<X> for Y pour convertir (utilisé par ?).
• Paramètres &str et &[T] ; valeurs renvoyées possédées.
• Itérateurs plutôt que boucles sur des indices.
• « Newtype » struct Euros(f64); : ne plus confondre deux unités.
• Rendre les états impossibles irreprésentables : une enum plutôt que des booléens combinés.
• Option pour l’absence, jamais de valeur sentinelle (-1, "").

• rust-analyzer : extension d’éditeur (VS Code…) — complétion, types affichés, erreurs en direct. cargo fmt et cargo clippy avant chaque commit.
• cargo clippy --fix : appliquer les corrections proposées.

• Le langage de programmation Rust (traduction du « Book ») : jimskapt.github.io/rust-book-fr
• Comprehensive Rust (Google), en français : google.github.io/comprehensive-rust/fr
• Rust by Example : doc.rust-lang.org/rust-by-example
• Rustlings, exercices guidés par le compilateur : github.com/rust-lang/rustlings
• Bibliothèque standard : doc.rust-lang.org/std · paquets : crates.io, docs.rs
• Essayer sans rien installer : play.rust-lang.org