Bases du langage

rustup update              # Met à jour la toolchain
rustup show                # Affiche la toolchain active
rustup default stable      # Définit le canal par défaut (stable, beta, nightly)
rustup component add clippy rustfmt
rustup doc                 # Ouvre la documentation hors-ligne

cargo new mon_projet       # Crée un projet binaire
cargo new ma_lib --lib     # Crée un projet bibliothèque
cargo build                # Compile en mode debug (dans target/debug)
cargo build --release      # Compile avec optimisations (dans target/release)
cargo run                  # Compile puis exécute
cargo check                # Vérifie la compilation sans produire de binaire (rapide)
cargo test                 # Lance les tests
cargo doc --open           # Génère et ouvre la documentation du projet
cargo clippy               # Analyse statique
cargo fmt                  # Formate le code

mon_projet
├── Cargo.toml
├── Cargo.lock
└── src
    └── main.rs

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

[dependencies]
serde = { version = "1.0", features = ["derive"] }

fn main() {
    println!("Hello, world !");
}

println!("Traitement terminé");
eprintln!("Attention : fichier de configuration absent");

let message = format!("{} éléments traités", 42);

let x = dbg!(2 + 3) * 4;
// [src/main.rs:2:13] 2 + 3 = 5

let nom = "Alice";
let age = 30;

println!("{nom} a {age} ans");            // Capture directe de la variable (Rust >= 1.58)
println!("{} a {} ans", nom, age);        // Positionnel implicite, dans l'ordre
println!("{0} a {1} ans, {0} encore", nom, age);   // Positionnel explicite, réutilisable
println!("{p} a {a} ans", p = nom, a = age);       // Nommé

println!("{}", utilisateur.nom);          // Correct
let n = &utilisateur.nom;
println!("{n}");                          // Correct également

println!("{{}} est un emplacement vide");     // Affiche : {} est un emplacement vide

#[derive(Debug)]
struct Point { x: i32, y: i32 }

let p = Point { x: 1, y: 2 };

println!("{p:?}");      // Point { x: 1, y: 2 }
println!("{p:#?}");     // Point {
                        //     x: 1,
                        //     y: 2,
                        // }
println!("{p}");        // Erreur : Point n'implémente pas Display

// Largeur et alignement
println!("[{:8}]", "abc");        // [abc     ]  gauche par défaut pour le texte
println!("[{:>8}]", "abc");       // [     abc]  à droite
println!("[{:^8}]", "abc");       // [  abc   ]  centré
println!("[{:*^8}]", "abc");      // [**abc***]  avec caractère de remplissage
println!("[{:8}]", 42);           // [      42]  droite par défaut pour les nombres

// Précision
println!("{:.2}", 3.14159);       // 3.14
println!("{:.3}", "abcdefgh");    // abc   — sur du texte, c'est une troncature

// Signe et remplissage par zéros
println!("{:+}", 42);             // +42
println!("{:08.3}", 3.14159);     // 0003.142

// Bases et notation
println!("{:b}", 42);             // 101010
println!("{:o}", 42);             // 52
println!("{:x} {:X}", 255, 255);  // ff FF
println!("{:#x} {:#b}", 255, 5);  // 0xff 0b101   — le # ajoute le préfixe
println!("{:e}", 1234.5);         // 1.2345e3

let largeur = 10;
let precision = 3;
println!("{:largeur$.precision$}", 3.14159);      // Nommé
println!("{:1$.2$}", 3.14159, largeur, precision); // Positionnel

let message = String::from("Bonjour");
println!("{message}");
println!("{message}");        // Toujours disponible : rien n'a été déplacé

use log::{debug, error, info, trace, warn};

info!("serveur démarré sur le port {port}");
warn!("nouvelle tentative dans {delai} ms");
error!("échec de la connexion : {e}");

RUST_LOG=debug cargo run        # Filtrage sans recompiler

use tracing::{info, instrument};

#[instrument]                                  // Trace automatiquement les arguments
async fn traiter(id: u64) {
    info!(utilisateur = %id, "traitement démarré");
}

// Commentaire sur une ligne

/*
  Commentaire sur
  plusieurs lignes
*/

/// Commentaire de documentation, décrit l'élément qui suit.
/// Il accepte du Markdown et est repris par `cargo doc`.
fn ma_fonction() {}

//! Commentaire de documentation, décrit l'élément qui le contient
//! (placé en tête de fichier, il documente le module).

let x = 5;
x = 6;          // Erreur de compilation : cannot assign twice to immutable variable

let mut y = 5;
y = 6;          // OK

let age: u32 = 30;

let valeur = "42";
let valeur = valeur.parse::<i32>().unwrap();   // valeur est maintenant un i32

const MAX_POINTS: u32 = 100_000;   // Toujours immutable, type obligatoire, inlinée
static NOM: &str = "Rust";         // Emplacement mémoire unique, durée de vie du programme

// Tuple : taille fixe, types hétérogènes
let point: (i32, i32, &str) = (3, 5, "origine");
let (x, y, nom) = point;      // Déstructuration
println!("{}", point.0);      // Accès par index

// Tableau : taille fixe, types homogènes, alloué sur la pile
let jours = ["Lun", "Mar", "Mer"];
let zeros: [i32; 5] = [0; 5];  // [0, 0, 0, 0, 0]
println!("{}", jours[0]);

// Vecteur : taille variable, alloué sur le tas
let mut nombres: Vec<i32> = Vec::new();
nombres.push(1);
let autres = vec![1, 2, 3];

let litteral: &str = "Hello";
let mut possedee: String = String::from("Hello");
possedee.push_str(", world !");

let conversion: String = litteral.to_string();
let emprunt: &str = &possedee;      // Déréférencement automatique

fn additionner(a: i32, b: i32) -> i32 {
    a + b       // Pas de point-virgule : c'est l'expression de retour
}

fn afficher(message: &str) {
    println!("{message}");
}

let nombre = 6;

if nombre % 2 == 0 {
    println!("Pair");
} else if nombre % 3 == 0 {
    println!("Divisible par 3");
} else {
    println!("Impair");
}

let etiquette = if nombre % 2 == 0 { "pair" } else { "impair" };

// loop : infinie, et seule forme pouvant renvoyer une valeur via break
let mut compteur = 0;
let resultat = loop {
    compteur += 1;
    if compteur == 10 {
        break compteur * 2;
    }
};

// while
while compteur != 0 {
    compteur -= 1;
}

// for : parcours d'un itérateur
let jours = ["Lun", "Mar", "Mer"];

for jour in jours {
    println!("{jour}");
}

for i in 0..5 {          // 0 à 4 (0..=5 pour inclure 5)
    println!("{i}");
}

for (index, jour) in jours.iter().enumerate() {
    println!("{index} : {jour}");
}

let note = 15;

let mention = match note {
    0..=9 => "Insuffisant",
    10..=11 => "Passable",
    12..=13 => "Assez bien",
    14..=15 => "Bien",
    _ => "Très bien",      // Motif par défaut
};

if let Some(valeur) = resultat_optionnel {
    println!("{valeur}");
}

let s1 = String::from("Hello");
let s2 = s1;                  // La propriété est déplacée (move) de s1 vers s2
println!("{s1}");             // Erreur : borrow of moved value

fn longueur(s: &String) -> usize {
    s.len()
}

let s = String::from("Hello");
let n = longueur(&s);         // s est emprunté, pas déplacé
println!("{s} fait {n} caractères");   // s est toujours utilisable

fn ajouter(s: &mut String) {
    s.push_str(" !");
}

let mut s = String::from("Hello");
ajouter(&mut s);

enum Option<T> {
    Some(T),
    None,
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

// Option : une valeur peut être absente
let nombres = vec![1, 2, 3];
let element: Option<&i32> = nombres.get(10);
match element {
    Some(v) => println!("Trouvé : {v}"),
    None => println!("Aucun élément"),
}

// Result : une opération peut échouer
let nombre: Result<i32, _> = "42".parse::<i32>();
match nombre {
    Ok(n) => println!("Converti : {n}"),
    Err(e) => println!("Erreur : {e}"),
}

fn lire_config(chemin: &str) -> Result<String, std::io::Error> {
    let contenu = std::fs::read_to_string(chemin)?;   // Retourne l'Err immédiatement
    Ok(contenu)
}