Rust : match

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

//Le match est plus ou moins comme un case en bash
//Il est composé de "bras" du type pattern => conséquence
//Ici on la fonction renvoie une valeur numérique.
//La syntaxe peut paraître confuse...
fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

//...mais c'est parce que chaque conséquence est un bloc de code
//, on peut s'éviter les curly braces si le code est court
//ou les faire apparaître comme ici
fn value_in_cents_curly(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => {
            return 1;
        }
        Coin::Nickel => {
            println!("Something");
            return 5;
        }
        //Un match se DOIT d'être exhaustif...
        //Le dernier bras peut couvrir tous les cas restants si besoin
        //Comme ici
        //À noter, je me dois de renvoyer qq chose
        //comme dit dans la signature de la fonction
        autre => {
            println!("...?");
            return 20;
        }
    }
}

fn useless_but_fun() {
    let mynumber = 6;
    match mynumber {

        //D'ailleurs, je peux utiliser _ comme catch-all
        //Si j'ai besoin d'un ctach-all mais pas besoin de la
        //valeur en elle même
        3 => println!("Wahou"),
        5 => println!("Ho yeah"),
        _ => println!("I don't even care about your value")
        //Si je voulais ne rien faire sur le catch-all, je ferais
        //_ => ()
    }
}


//Récupérer des valeurs
//Mettons sque je collectionne les pièces d'un centime en fonction de leur
//pays...

#[derive(Debug)]
enum EuCountry {
    France,
    England, 
    Deutschland,
    Sweden
}

enum EuroCoin {
    OneEuro,
    FiftyCents,
    //Ma pièce d'un centime est spéciale, je veux connaitre son pays;
    //donc je lui fait un tuple
    OneCent(EuCountry)
}

fn match_euro(coin: EuroCoin) -> u8 {
    match coin {
        EuroCoin::OneEuro => 100,
        EuroCoin::FiftyCents => 50,
        EuroCoin::OneCent(country) => {
            //Je peux utiliser sa donnée de pays
            println!("Nice, it is from {:?}", country);
            1
        }
    }
}


//Option<T>
//Option<T> est un enum spécial, présent sans même avoir à l'importer
//il remplace le NULL. le <T> signifie Type, AKA n'importe lequel
//Il est composé de 2 éléments, Some(T) si on a quelque chose
//et None si on a rien. Il a plein de méthodes, cf la doc
//On peut matcher dessus

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        None => None,
        Some(i) => Some(i + 1),
    }
}


fn main() {
    let mycoin = Coin::Dime;
    let myothercoin = Coin::Nickel;
    println!("My coin is worth {} cents", value_in_cents(mycoin));
    println!("My coin is worth {} cents", value_in_cents_curly(myothercoin));

    let euro_coin = EuroCoin::OneCent(EuCountry::Sweden);
    println!("My euro coin is worth {} cents", match_euro(euro_coin));

    useless_but_fun();
}