Gestion des erreurs

fn main() {
    panic!("état impossible : {}", 42);
}
// thread 'main' panicked at src/main.rs:2:5:
// état impossible : 42

D'autres opérations paniquent d'elles-mêmes :

let v = vec![1, 2, 3];
// v[10];                          // index out of bounds
// let x: u8 = 255; x + 1;         // dépassement (en debug)
// 1 / 0;                          // division par zéro
// None::<i32>.unwrap();           // called `Option::unwrap()` on a `None` value

enum Result<T, E> {
    Ok(T),     // la valeur
    Err(E),    // la raison de l'échec
}

use std::fs::File;

fn main() {
    let f = File::open("config.toml");    // Result<File, std::io::Error>
    match f {
        Ok(fichier) => println!("ouvert : {fichier:?}"),
        Err(e) => println!("impossible d'ouvrir : {e}"),
    }
}

std::fs::remove_file("tmp.txt");          // avertissement : unused `Result` that must be used
let _ = std::fs::remove_file("tmp.txt");  // ignorer volontairement, et le dire

fn age_v1(t: &str) -> u32 {
    // 1. match : tous les cas, accès à l'erreur
    match t.trim().parse::<u32>() {
        Ok(n) => n,
        Err(e) => {
            eprintln!("âge invalide ({e}) : 0 par défaut");
            0
        }
    }
}

fn age_v2(t: &str) -> u32 {
    // 2. if let : seul le succès compte
    if let Ok(n) = t.trim().parse::<u32>() {
        n
    } else {
        0
    }
}

fn age_v3(t: &str) -> u32 {
    // 3. let else : le cas d'erreur sort de la fonction
    let Ok(n) = t.trim().parse::<u32>() else {
        return 0;
    };
    n
}

fn age_v4(t: &str) -> u32 {
    // 4. méthode : la plus courte
    t.trim().parse().unwrap_or(0)
}

fn age_v5(t: &str) -> u32 {
    // 5. unwrap_or_else : accès à l'erreur, valeur calculée seulement en cas d'échec
    t.trim().parse().unwrap_or_else(|e| {
        eprintln!("âge invalide ({e})");
        0
    })
}

let r: Result<i32, String> = Ok(2);

// Extraire
r.clone().unwrap_or(0);
r.clone().unwrap_or_default();
r.clone().unwrap_or_else(|_e| 0);

// Transformer
r.clone().map(|n| n * 10);                       // Ok(20)
r.clone().map_err(|e| format!("erreur : {e}"));  // change le type d'erreur
r.clone().and_then(|n| if n > 0 { Ok(n) } else { Err("négatif".to_string()) });
r.clone().or_else(|_e| Ok::<i32, String>(0));    // récupérer une erreur
r.clone().map_or(0, |n| n * 2);                  // transformer ou valeur de secours

// Tester
r.is_ok();
r.is_err();
r.as_ref().is_ok_and(|&n| n > 1);
r.as_ref().is_err_and(|e| e.is_empty());

// Convertir
r.clone().ok();                                  // Option<i32> : l'erreur est perdue
r.clone().err();                                 // Option<String>

// Inspecter sans modifier
let _ = r.clone().inspect_err(|e| eprintln!("{e}"));

let n: i32 = "42".parse().unwrap();                    // panique avec l'erreur si échec
let n: i32 = "42".parse().expect("constante valide");  // panique avec TON message + l'erreur

// 1. Tests
#[test]
fn lit() { assert_eq!("1".parse::<i32>().unwrap(), 1); }

// 2. Valeur constante, vérifiable à l'œil
let ip: std::net::IpAddr = "127.0.0.1".parse().unwrap();

// 3. Juste après une vérification
let v = vec![1];
if !v.is_empty() {
    let premier = v.first().unwrap();      // mais `if let Some(p) = v.first()` est plus sûr
}

// 4. Verrou empoisonné : un autre thread a déjà paniqué
let m = std::sync::Mutex::new(0);
let garde = m.lock().unwrap();

Partout ailleurs, unwrap dans du code de production transforme une erreur récupérable en arrêt brutal.

use std::fs;
use std::io;

fn lire_config() -> Result<String, io::Error> {
    let contenu = fs::read_to_string("config.toml")?;
    Ok(contenu.trim().to_string())
}

expression? est équivalent à :

let contenu = match fs::read_to_string("config.toml") {
    Ok(valeur) => valeur,
    Err(e) => return Err(From::from(e)),   // sort de la fonction avec l'erreur, convertie
};

Trois effets :

1. en cas de succès, donne la valeur ;
2. en cas d'erreur, quitte la fonction immédiatement ;
3. convertit l'erreur avec From, vers le type d'erreur de la fonction.

fn lire_port() -> Result<u16, Box<dyn std::error::Error>> {
    let port = std::fs::read_to_string("port.txt")?.trim().parse::<u16>()?;
    Ok(port)
}

Chaque ? peut faire sortir la fonction. La ligne se lit de gauche à droite : lire, puis découper, puis convertir.

fn initiale_du_nom(texte: &str) -> Option<char> {
    let nom = texte.split_whitespace().nth(1)?;   // None : la fonction renvoie None
    nom.chars().next()
}

? fonctionne sur Option dans une fonction qui renvoie Option, sur Result dans une fonction qui renvoie Result. On ne mélange pas directement les deux (section 7).

fn main() {
    // let n: i32 = "x".parse()?;    // ERREUR : main renvoie () (voir section 12)
}

let v = vec!["1", "x"];
// v.iter().map(|s| s.parse::<i32>()?);   // ERREUR : ? sortirait de la closure, qui ne renvoie pas Result

Dans une closure, ? sort de la closure, pas de la fonction englobante. Pour une liste : collect::<Result<Vec<_>, _>>()?.

fn tous(v: &[&str]) -> Result<Vec<i32>, std::num::ParseIntError> {
    let nombres = v.iter().map(|s| s.parse::<i32>()).collect::<Result<Vec<_>, _>>()?;
    Ok(nombres)
}

fn trouver(id: u32) -> Option<String> { (id == 1).then(|| "Ada".to_string()) }

fn nom(id: u32) -> Result<String, String> {
    // 1. ok_or : l'erreur est construite dans tous les cas
    let n = trouver(id).ok_or("utilisateur introuvable".to_string())?;

    // 2. ok_or_else : l'erreur n'est construite qu'en cas d'absence
    let n = trouver(id).ok_or_else(|| format!("utilisateur {id} introuvable"))?;

    // 3. let else
    let Some(n) = trouver(id) else {
        return Err(format!("utilisateur {id} introuvable"));
    };

    Ok(n)
}

fn port(t: &str) -> Option<u16> {
    t.parse().ok()            // l'erreur est jetée : à réserver aux cas où sa cause n'intéresse personne
}

let a: Option<Result<i32, String>> = Some(Ok(1));
let b: Result<Option<i32>, String> = a.transpose();   // Ok(Some(1))

// Utile pour un champ optionnel qui doit être valide s'il est présent
fn age_optionnel(t: Option<&str>) -> Result<Option<u32>, std::num::ParseIntError> {
    t.map(|s| s.parse::<u32>()).transpose()
}

use std::io::ErrorKind;

fn lire_ou_creer(chemin: &str) -> std::io::Result<String> {
    match std::fs::read_to_string(chemin) {
        Ok(c) => Ok(c),
        Err(e) if e.kind() == ErrorKind::NotFound => {
            std::fs::write(chemin, "")?;
            Ok(String::new())
        }
        Err(e) => Err(e),
    }
}

std::io::Result<T> est un alias de Result<T, std::io::Error>. Beaucoup de crates définissent le leur (fmt::Result, sea_orm::DbErr, AppResult dans Runique).

#[derive(Debug)]
pub enum ErreurInscription {
    EmailInvalide(String),
    MotDePasseTropCourt { longueur: usize, minimum: usize },
    DejaInscrit,
}

Une enum laisse l'appelant réagir à chaque cas (afficher un message sous le bon champ, renvoyer un 409...), ce qu'une simple String ne permet pas.

use std::fmt;

impl fmt::Display for ErreurInscription {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::EmailInvalide(e) => write!(f, "adresse email invalide : {e}"),
            Self::MotDePasseTropCourt { longueur, minimum } => {
                write!(f, "mot de passe trop court ({longueur} caractères, minimum {minimum})")
            }
            Self::DejaInscrit => write!(f, "cette adresse est déjà inscrite"),
        }
    }
}

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

Error demande Debug et Display. Il rend ton erreur compatible avec Box<dyn Error>, anyhow et tous les outils qui affichent une chaîne de causes.

#[derive(Debug)]
pub enum ErreurConfig {
    Lecture(std::io::Error),
    Format(std::num::ParseIntError),
}

impl fmt::Display for ErreurConfig {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Lecture(_) => write!(f, "impossible de lire la configuration"),
            Self::Format(_) => write!(f, "configuration mal formée"),
        }
    }
}

impl std::error::Error for ErreurConfig {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            Self::Lecture(e) => Some(e),
            Self::Format(e) => Some(e),
        }
    }
}

source relie l'erreur à celle qui l'a causée. Un outil d'affichage peut alors écrire « impossible de lire la configuration : fichier introuvable ». Règle : le Display décrit ton niveau, la cause est dans source ; ne répète pas le message de la cause dans les deux.

fn afficher_chaine(e: &dyn std::error::Error) {
    eprintln!("erreur : {e}");
    let mut cause = e.source();
    while let Some(c) = cause {
        eprintln!("  cause : {c}");
        cause = c.source();
    }
}

fn lire_port() -> Result<u16, ErreurConfig> {
    let t = std::fs::read_to_string("port")?;      // io::Error, pas ErreurConfig
    let p = t.trim().parse::<u16>()?;               // ParseIntError
    Ok(p)
}
// ERREUR : `?` couldn't convert the error to `ErreurConfig`

// 1. map_err à chaque appel
fn lire_port_v1() -> Result<u16, ErreurConfig> {
    let t = std::fs::read_to_string("port").map_err(ErreurConfig::Lecture)?;
    let p = t.trim().parse::<u16>().map_err(ErreurConfig::Format)?;
    Ok(p)
}

// 2. Implémenter From une fois : ? convertit tout seul
impl From<std::io::Error> for ErreurConfig {
    fn from(e: std::io::Error) -> Self { Self::Lecture(e) }
}
impl From<std::num::ParseIntError> for ErreurConfig {
    fn from(e: std::num::ParseIntError) -> Self { Self::Format(e) }
}

fn lire_port_v2() -> Result<u16, ErreurConfig> {
    let t = std::fs::read_to_string("port")?;
    let p = t.trim().parse::<u16>()?;
    Ok(p)
}

// 3. Box<dyn Error> : tout se convertit, mais l'appelant ne peut plus distinguer les cas
fn lire_port_v3() -> Result<u16, Box<dyn std::error::Error>> {
    let t = std::fs::read_to_string("port")?;
    Ok(t.trim().parse::<u16>()?)
}

map_err sert quand la même erreur source doit donner des variantes différentes selon l'endroit (deux fichiers différents, deux champs différents). From sert quand une erreur source correspond toujours à la même variante.

thiserror génère Display, Error, source et From à partir d'attributs : voir gestion-erreurs-avancee.

use std::error::Error;

fn charger() -> Result<u32, Box<dyn Error>> {
    let t = std::fs::read_to_string("n.txt")?;       // io::Error convertie
    let n: u32 = t.trim().parse()?;                   // ParseIntError convertie
    if n == 0 {
        return Err("zéro interdit".into());           // une &str devient aussi une erreur
    }
    Ok(n)
}

fn appel() {
    if let Err(e) = charger() {
        if let Some(io) = e.downcast_ref::<std::io::Error>() {
            eprintln!("problème de fichier : {}", io.kind());
        } else {
            eprintln!("autre erreur : {e}");
        }
    }
}

use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    let config = std::fs::read_to_string("config.toml")?;
    println!("{config}");
    Ok(())
}

use std::process::ExitCode;

fn main() -> ExitCode {
    match lancer() {
        Ok(()) => ExitCode::SUCCESS,
        Err(e) => {
            eprintln!("erreur : {e}");
            ExitCode::from(2)
        }
    }
}

fn lancer() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
}

lire_fichier()        → ne sait pas si l'absence est grave       → ?
charger_config()      → sait qu'une config absente = valeurs par défaut → traite
demarrer_serveur()    → une config illisible empêche de démarrer → ? jusqu'à main
main()                → affiche l'erreur et sort avec un code     → traite

fn sauver(contenu: &str) {
    // Mauvais : l'échec disparaît sans trace
    let _ = std::fs::write("data.txt", contenu);

    // Mieux : au minimum, le journaliser
    if let Err(e) = std::fs::write("data.txt", contenu) {
        eprintln!("sauvegarde échouée : {e}");
    }
}

use std::fs;

// 1. Prototype : panique à la moindre erreur
fn somme_v1(chemin: &str) -> i64 {
    fs::read_to_string(chemin).unwrap()
        .lines()
        .map(|l| l.trim().parse::<i64>().unwrap())
        .sum()
}

// 2. Box<dyn Error> : toutes les erreurs remontent, sans distinction
fn somme_v2(chemin: &str) -> Result<i64, Box<dyn std::error::Error>> {
    let mut total = 0;
    for ligne in fs::read_to_string(chemin)?.lines() {
        total += ligne.trim().parse::<i64>()?;
    }
    Ok(total)
}

// 3. Itérateur + collect dans un Result
fn somme_v3(chemin: &str) -> Result<i64, Box<dyn std::error::Error>> {
    let texte = fs::read_to_string(chemin)?;
    let nombres = texte
        .lines()
        .map(|l| l.trim().parse::<i64>())
        .collect::<Result<Vec<i64>, _>>()?;
    Ok(nombres.iter().sum())
}

// 4. Erreur typée : l'appelant sait quelle ligne est fausse
#[derive(Debug)]
enum ErreurSomme {
    Lecture(std::io::Error),
    Ligne { numero: usize, texte: String },
}

fn somme_v4(chemin: &str) -> Result<i64, ErreurSomme> {
    let texte = fs::read_to_string(chemin).map_err(ErreurSomme::Lecture)?;
    let mut total = 0;
    for (i, ligne) in texte.lines().enumerate() {
        let n: i64 = ligne.trim().parse().map_err(|_| ErreurSomme::Ligne {
            numero: i + 1,
            texte: ligne.to_string(),
        })?;
        total += n;
    }
    Ok(total)
}

// 5. Tolérante : ignore les lignes invalides
fn somme_v5(chemin: &str) -> std::io::Result<i64> {
    Ok(fs::read_to_string(chemin)?
        .lines()
        .filter_map(|l| l.trim().parse::<i64>().ok())
        .sum())
}

panic!("msg")                         // bug : arrête le thread
Result<T, E>   Ok(v)   Err(e)         // erreur attendue
r?                                    // propage, convertit avec From
r.unwrap()   r.expect("pourquoi c'est impossible")
r.unwrap_or(v)   r.unwrap_or_else(|e| ..)   r.unwrap_or_default()
r.map(f)   r.map_err(f)   r.and_then(f)   r.ok()   r.is_ok_and(p)
opt.ok_or(e)   opt.ok_or_else(|| e)   opt?   opt_res.transpose()
iter.collect::<Result<Vec<_>, _>>()?
impl fmt::Display for MonErreur { .. }
impl std::error::Error for MonErreur { fn source(&self) -> .. }
impl From<io::Error> for MonErreur { .. }
fn main() -> Result<(), Box<dyn Error>> { .. }