Rust : match

<syntaxhighlight lang='rust'> 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...

1. [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();

} </syntaxhighlight>