Rust par l'exemple

fn give_princess(gift: &str) {
    // Les princesses détestent les serpents, donc nous devons tout arrêter si elles n'acceptent pas !
    if gift == "snake" { panic!("AAAaaaaa!!!!"); }

    println!("I love {}s!!!!!", gift);
}

fn main() {
    give_princess("teddy bear");
    give_princess("snake");
}

// Le roturier a déjà tout vu et accepte de bon coeur n'importe quel présent.
// Tous les présents sont gérés explicitement en utilisant `match`.
fn give_commoner(gift: Option<&str>) {
    // On définit une action pour chaque cas.
    match gift {
        Some("snake") => println!("Yuck! I'm throwing that snake in a fire."),
        Some(inner)   => println!("{}? How nice.", inner),
        None          => println!("No gift? Oh well."),
    }
}

// Notre précieuse princesse va `panic` à la vue des serpents.
// Tous les présents sont gérés implicitement en utilisant `unwrap`.
fn give_princess(gift: Option<&str>) {
    // `unwrap` renvoie un `panic` lorsqu'il reçoit la variante `None`.
    let inside = gift.unwrap();
    if inside == "snake" { panic!("AAAaaaaa!!!!"); }

    println!("I love {}s!!!!!", inside);
}

fn main() {
    let food  = Some("cabbage");
    let snake = Some("snake");
    let void  = None;

    give_commoner(food);
    give_commoner(snake);
    give_commoner(void);

    let bird = Some("robin");
    let nothing = None;

    give_princess(bird);
    give_princess(nothing);
}

fn double_number(number_str: &str) -> i32 {
    // Essayons d'utiliser la méthode `unwrap` pour récupérer le nombre.
    // Va-t-elle nous mordre ?
    2 * number_str.parse::<i32>().unwrap()
}

fn main() {
    let twenty = double_number("10");
    println!("double is {}", twenty);

    let tt = double_number("t");
    println!("double is {}", tt);
}

fn double_first(vec: Vec<&str>) -> i32 {
    let first = vec.first().unwrap(); // Génère la première erreur.
    2 * first.parse::<i32>().unwrap() // Génère la seconde erreur.
}

fn main() {
    let empty = vec![];
    let strings = vec!["tofu", "93", "18"];

    println!("The first doubled is {}", double_first(empty));
    // Erreur 1: Le vecteur passé en entrée est vide.

    println!("The first doubled is {}", double_first(strings));
    // Erreur 2: L'élément ne peut pas être converti en nombre.
}

// Nous utiliserons `String` en tant que type d'erreur.
type Result<T> = std::result::Result<T, String>;

fn double_first(vec: Vec<&str>) -> Result<i32> {
    vec.first()
       // On convertit l'`Option` en un `Result` s'il y a une valeur.
       // Autrement, on fournit une instance `Err` contenant la `String`.
       .ok_or("Please use a vector with at least one element.".to_owned())
       .and_then(|s| s.parse::<i32>()
                      // On convertit n'importe quelle erreur, générée par `parse`,
                      // en `String`.
                      .map_err(|e| e.to_string())
                      // `Result<T, String>` est le nouveau type de valeur,
                      // et nous pouvons doubler le nombre se trouvant dans le conteneur.
                      .map(|i| 2 * i))
}

fn print(result: Result<i32>) {
    match result {
        Ok(n)  => println!("The first doubled is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    let empty = vec![];
    let strings = vec!["tofu", "93", "18"];

    print(double_first(empty));
    print(double_first(strings));
}

use std::num::ParseIntError;
use std::fmt;

type Result<T> = std::result::Result<T, DoubleError>;

#[derive(Debug)]
// On définit nos propres types d'erreur. Ces derniers peuvent être personnalisés pour
// notre gestion des cas.
// Maintenant nous serons capables d'écrire nos propres erreurs et nous reporter
// à leur implémentation.
enum DoubleError {
    // Il n'est pas nécessaire de collecter plus d'informations
    // pour détailler cette erreur.
    EmptyVec,
    // Nous allons nous reporter à l'implémentation couvrant l'erreur de conversion pour ce type.
    // Soumettre des informations supplémentaires nécéssite l'ajout de données pour le type.
    Parse(ParseIntError),
}

// La génération d'une erreur fait abstraction de la manière dont elle est affichée,
// nul besoin de s'occuper de la mécanique sous-jacente.
//
// Notez que nous ne stockons aucune information supplémentaire à propos de l'erreur.
// Cela signifie que nous ne pouvons préciser quelle chaîne de caractères n'a pas pu être
// convertie, sans modifier nos types pour apporter cette information.
impl fmt::Display for DoubleError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DoubleError::EmptyVec => write!(f, "please use a vector with at least one element"),
            // Ceci est un wrapper, donc référrez-vous à l'implémentation de `fmt` respective
            // à chaque type.
            DoubleError::Parse(ref e) => e.fmt(f),
        }
    }
}

fn double_first(vec: Vec<&str>) -> Result<i32> {
    vec.first()
       // On remplace l'erreur par notre nouveau type.
       .ok_or(DoubleError::EmptyVec)
       .and_then(|s| s.parse::<i32>()
            // On met également à jour le nouveau type d'erreur ici.
            .map_err(DoubleError::Parse)
            .map(|i| 2 * i))
}

fn print(result: Result<i32>) {
    match result {
        Ok(n) => println!("The first doubled is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    let numbers = vec!["93", "18"];
    let empty = vec![];
    let strings = vec!["tofu", "93", "18"];

    print(double_first(numbers));
    print(double_first(empty));
    print(double_first(strings));
}

use std::num::ParseIntError;
use std::fmt;

type Result<T> = std::result::Result<T, DoubleError>;

#[derive(Debug)]
enum DoubleError {
    EmptyVec,
    Parse(ParseIntError),
}

// On implémente la conversion du type `ParseIntError` au type `DoubleError`.
// La conversion sera automatiquement appelée par `try!` si une instance `ParseIntError`
// doit être convertie en `DoubleError`.
impl From<ParseIntError> for DoubleError {
    fn from(err: ParseIntError) -> DoubleError {
        DoubleError::Parse(err)
    }
}

impl fmt::Display for DoubleError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DoubleError::EmptyVec =>
                write!(f, "please use a vector with at least one element"),
            DoubleError::Parse(ref e) => e.fmt(f),
        }
    }
}

// La même structure qu'avant mais, plutôt que de chaîner les instances `Result` 
// et `Option` tout du long, nous utilisons `try!` pour récupérer immédiatement 
// la valeur contenue.
fn double_first(vec: Vec<&str>) -> Result<i32> {
    // Convertit toujours en `Result` tout en renseignant comment convertir 
    // un `None`.
    let first = try!(vec.first().ok_or(DoubleError::EmptyVec));
    let parsed = try!(first.parse::<i32>());

    Ok(2 * parsed)
}

fn print(result: Result<i32>) {
    match result {
        Ok(n)  => println!("The first doubled is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    let numbers = vec!["93", "18"];
    let empty = vec![];
    let strings = vec!["tofu", "93", "18"];

    print(double_first(numbers));
    print(double_first(empty));
    print(double_first(strings));
}

trait Error: Debug + Display {
    fn description(&self) -> &str;
    fn cause(&self) -> Option<&Error>;
}

use std::error;
use std::fmt;
use std::num::ParseIntError;

// On modifie l'alias pour ajouter `Box<error::Error>`.
type Result<T> = std::result::Result<T, Box<error::Error>>;

#[derive(Debug)]
enum DoubleError {
    EmptyVec,
    Parse(ParseIntError),
}

impl From<ParseIntError> for DoubleError {
    fn from(err: ParseIntError) -> DoubleError {
        DoubleError::Parse(err)
    }
}

impl fmt::Display for DoubleError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            DoubleError::EmptyVec =>
                write!(f, "please use a vector with at least one element"),
            DoubleError::Parse(ref e) => e.fmt(f),
        }
    }
}

impl error::Error for DoubleError {
    fn description(&self) -> &str {
        match *self {
            // Courte description de l'erreur.
            // Vous n'êtes pas obligé de renseigner la même description que 
            // pour `Display`.
            DoubleError::EmptyVec => "empty vectors not allowed",
            // Ceci implémente déjà `Error`, on se reporte à sa propre implémentation.
            DoubleError::Parse(ref e) => e.description(),
        }
    }

    fn cause(&self) -> Option<&error::Error> {
        match *self {
            // Pas de cause (i.e. pas d'autre erreur) 
            // sous-jacente au déclenchement de cette erreur, donc on renvoie `None`.
            DoubleError::EmptyVec => None,
            // La cause est l'implémentation sous-jacente du type d'erreur. 
            // Il (le type) est implicitement casté en `&error::Error`. 
            // Ca fonctionne parce que le type en question a déjà implémenté le trait `Error`.
            DoubleError::Parse(ref e) => Some(e),
        }
    }
}

fn double_first(vec: Vec<&str>) -> Result<i32> {
    let first = try!(vec.first().ok_or(DoubleError::EmptyVec));
    let parsed = try!(first.parse::<i32>());

    Ok(2 * parsed)
}

fn print(result: Result<i32>) {
    match result {
        Ok(n)  => println!("The first doubled is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    let numbers = vec!["93", "18"];
    let empty = vec![];
    let strings = vec!["tofu", "93", "18"];

    print(double_first(numbers));
    print(double_first(empty));
    print(double_first(strings));
}