1. Introduction à Rust : installation, Cargo et premier programme

Dans cette première unité, vous allez installer l’environnement Rust, découvrir Cargo (le gestionnaire de paquets officiel) et écrire votre premier programme. Vous apprendrez la syntaxe de base du langage : variables, types primitifs, fonctions et structures de contrôle. À la fin de ce chapitre, vous serez capable de créer, compiler et exécuter un projet Rust simple.

Pourquoi choisir Rust ?

Rust a été conçu pour résoudre deux problèmes historiques du développement système : les bugs de sécurité mémoire (segfaults, use-after-free, data races) et les performances dégradées par les garbage collectors. Là où C donne la liberté totale au prix de la sécurité, et où Java ou Python sacrifient les performances pour la sécurité, Rust trouve un troisième chemin : la sécurité mémoire garantie à la compilation, sans coût à l’exécution.

Le résultat : des programmes aussi rapides que du C, mais qui ne peuvent pas planter à cause d’une mauvaise gestion de la mémoire. C’est pourquoi Rust est aujourd’hui utilisé dans les navigateurs (Firefox), les systèmes d’exploitation (Linux, Windows), les blockchains, les moteurs de jeu, les CLIs et bien sûr les utilitaires système.

Installation de la toolchain avec rustup

La façon officielle et recommandée d’installer Rust est via rustup, un gestionnaire de toolchain qui permet de basculer entre les versions stable, beta et nightly.

# Installation de rustup (Linux/macOS)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Recharger le PATH
source $HOME/.cargo/env

# Vérifier l'installation
rustc --version   # ex: rustc 1.78.0
cargo --version   # ex: cargo 1.78.0

Rustup installe trois composants essentiels : rustc (le compilateur), cargo (le gestionnaire de paquets et build tool) et rustfmt (le formateur de code). Sur Windows, l’installateur rustup-init.exe effectue la même opération.

Cargo : bien plus qu’un gestionnaire de paquets

Cargo est l’outil central de l’écosystème Rust. Il gère la création de projets, les dépendances, la compilation, les tests et la publication de crates (bibliothèques Rust). Voici les commandes essentielles :

# Créer un nouveau projet binaire
cargo new mon-utilitaire

# Créer une bibliothèque
cargo new --lib ma-bibliotheque

# Compiler (mode debug)
cargo build

# Compiler en mode release (optimisé)
cargo build --release

# Compiler ET exécuter
cargo run

# Lancer les tests
cargo test

# Ajouter une dépendance
cargo add regex

La structure d’un projet Cargo est standardisée : un fichier Cargo.toml (métadonnées et dépendances), un dossier src/ contenant le code source, et un dossier target/ pour les artefacts de compilation.

Votre premier programme Rust

Le traditionnel Hello World en Rust introduit déjà plusieurs concepts importants :

fn main() {
    println!("Bonjour, Culte du Code !");

    // Variables : immuables par défaut
    let message = "Rust est formidable";
    let nombre: i32 = 42;

    // Rendre une variable mutable avec mut
    let mut compteur = 0;
    compteur += 1;

    println!("{} — nombre: {}, compteur: {}", message, nombre, compteur);
}

Les types primitifs essentiels

Rust est un langage à typage statique fort. Le compilateur infère souvent le type, mais vous pouvez l’annoter explicitement. Les types de base sont : i8, i16, i32, i64, i128 (entiers signés), u8, u16, u32, u64, u128 (non signés), f32, f64 (flottants), bool et char (Unicode 4 octets).

fn additionner(a: i32, b: i32) -> i32 {
    a + b  // pas de point-virgule = valeur de retour implicite
}

fn main() {
    let resultat = additionner(10, 32);
    println!("10 + 32 = {}", resultat);

    // if/else est une expression en Rust
    let statut = if resultat > 40 { "grand" } else { "petit" };
    println!("Le résultat est {}", statut);

    // Boucle for sur un range
    for i in 0..5 {
        print!("{} ", i);
    }
}