Gérer les erreurs : Option, Result et l'opérateur ?

enum Result<T, E> {
    Ok(T),  // succès, avec la valeur
    Err(E), // échec, avec l'erreur
}

fn main() {
    for saisie in ["89900", "899,00", "-5", ""] {
        let resultat: Result<u32, std::num::ParseIntError> = saisie.parse();
        match resultat {
            Ok(prix) => println!("« {saisie} » → {prix} centimes"),
            Err(e) => println!("« {saisie} » refusé : {e}"),
        }
    }
}

« 89900 » → 89900 centimes
« 899,00 » refusé : invalid digit found in string
« -5 » refusé : invalid digit found in string
«  » refusé : cannot parse integer from empty string

fn main() {
    let saisie = "899,00";
    let prix: u32 = saisie.parse().expect("le prix doit être un nombre de centimes");
    println!("{prix}");
}

thread 'main' (13771) panicked at src/main.rs:3:36:
le prix doit être un nombre de centimes: ParseIntError { kind: InvalidDigit }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

fn main() {
    let numeros = ["PC-0001", "PC-0002", "PC-0007"];

    let trouve: Option<&&str> = numeros.iter().find(|n| n.ends_with("07"));
    println!("{trouve:?}");

    let absent = numeros.iter().find(|n| n.ends_with("99"));
    println!("{absent:?}");

    // Valeur par défaut, transformation, conversion en Result
    let nom: Option<&str> = None;
    println!("{}", nom.unwrap_or("personne"));
    println!("{:?}", Some("julie").map(|n| n.to_uppercase()));
    let r: Result<&str, String> = nom.ok_or(String::from("poste non affecté"));
    println!("{r:?}");

    // get renvoie une Option au lieu de paniquer
    println!("{:?} {:?}", numeros.get(1), numeros.get(10));
}

Some("PC-0007")
None
personne
Some("JULIE")
Err("poste non affecté")
Some("PC-0002") None

use std::num::ParseIntError;

/// « 89900;2023 » → (89900, 2023).
fn lire_prix_et_annee(ligne: &str) -> Result<(u32, i32), ParseIntError> {
    let (prix, annee) = ligne.split_once(';').unwrap_or((ligne, ""));
    let prix: u32 = prix.trim().parse()?; // en cas d'erreur, on la renvoie tout de suite
    let annee: i32 = annee.trim().parse()?;
    Ok((prix, annee))
}

// La même fonction sans ?, pour voir ce qu'il fait à ta place
fn lire_prix_et_annee_long(ligne: &str) -> Result<(u32, i32), ParseIntError> {
    let (prix, annee) = ligne.split_once(';').unwrap_or((ligne, ""));
    let prix: u32 = match prix.trim().parse() {
        Ok(valeur) => valeur,
        Err(e) => return Err(e),
    };
    let annee: i32 = match annee.trim().parse() {
        Ok(valeur) => valeur,
        Err(e) => return Err(e),
    };
    Ok((prix, annee))
}

fn main() {
    println!("{:?}", lire_prix_et_annee("89900;2023"));
    println!("{:?}", lire_prix_et_annee("89900;deux mille"));
    println!("{:?}", lire_prix_et_annee_long("89900"));
}

Ok((89900, 2023))
Err(ParseIntError { kind: InvalidDigit })
Err(ParseIntError { kind: Empty })

use std::fmt;

#[derive(Debug)]
enum ErreurParc {
    NombreDeChamps(usize),
    TypeInconnu(String),
    NombreInvalide(String),
}

impl fmt::Display for ErreurParc {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ErreurParc::NombreDeChamps(n) => write!(f, "4 champs attendus, {n} trouvés"),
            ErreurParc::TypeInconnu(t) => write!(f, "type de poste inconnu : « {t} »"),
            ErreurParc::NombreInvalide(n) => write!(f, "nombre invalide : « {n} »"),
        }
    }
}

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

#[derive(Debug, Clone, Copy, PartialEq)]
enum TypePoste {
    Fixe,
    Portable,
    Serveur,
}

#[derive(Debug)]
struct Poste {
    numero: String,
    type_poste: TypePoste,
    prix_ht: u32,
    annee_achat: i32,
}

fn lire_type(texte: &str) -> Result<TypePoste, ErreurParc> {
    match texte {
        "fixe" => Ok(TypePoste::Fixe),
        "portable" => Ok(TypePoste::Portable),
        "serveur" => Ok(TypePoste::Serveur),
        autre => Err(ErreurParc::TypeInconnu(autre.to_string())),
    }
}

/// « PC-0001;portable;89900;2023 » → Poste.
fn lire_ligne(ligne: &str) -> Result<Poste, ErreurParc> {
    let champs: Vec<&str> = ligne.split(';').collect();
    if champs.len() != 4 {
        return Err(ErreurParc::NombreDeChamps(champs.len()));
    }
    Ok(Poste {
        numero: champs[0].to_string(),
        type_poste: lire_type(champs[1])?,
        prix_ht: champs[2]
            .parse()
            .map_err(|_| ErreurParc::NombreInvalide(champs[2].to_string()))?,
        annee_achat: champs[3]
            .parse()
            .map_err(|_| ErreurParc::NombreInvalide(champs[3].to_string()))?,
    })
}

fn main() {
    let lignes = [
        "PC-0001;portable;89900;2023",
        "PC-0002;tablette;45000;2024",
        "PC-0003;fixe;649,00;2020",
        "PC-0004;fixe",
    ];
    for ligne in lignes {
        match lire_ligne(ligne) {
            Ok(p) => println!("OK : {} {:?} {} {}", p.numero, p.type_poste, p.prix_ht, p.annee_achat),
            Err(e) => println!("Erreur : {e}"),
        }
    }
}

OK : PC-0001 Portable 89900 2023
Erreur : type de poste inconnu : « tablette »
Erreur : nombre invalide : « 649,00 »
Erreur : 4 champs attendus, 2 trouvés

impl From<std::io::Error> for ErreurParc {
    fn from(e: std::io::Error) -> Self {
        ErreurParc::Fichier(e)
    }
}

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

fn compter_postes(chemin: &str) -> Result<usize, std::io::Error> {
    let contenu = fs::read_to_string(chemin)?;
    Ok(contenu.lines().skip(1).filter(|l| !l.trim().is_empty()).count())
}

fn main() -> Result<(), Box<dyn Error>> {
    let nombre = compter_postes("parc-introuvable.csv")?;
    println!("{nombre} postes");
    Ok(())
}

Error: Os { code: 2, kind: NotFound, message: "No such file or directory" }