Justine le 3 novembre 2022 à 09:18

2022-11-03T09:18:44Z

← Version précédente		Version du 3 novembre 2022 à 09:18
Ligne 1 :		Ligne 1 :
	<~~nowiki~~>		<syntaxhighlight lang='rust'>
	enum Coin {		enum Coin {
	Penny,		Penny,
Ligne 119 :		Ligne 119 :
	useless_but_fun();		useless_but_fun();
	}		}
	</~~nowiki~~>		</syntaxhighlight>

Justine : Page créée avec «  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... »

2022-11-03T09:13:58Z

Page créée avec «  <nowiki> 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... »

Nouvelle page

<nowiki>
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();
}
</nowiki>

Rust : match - Historique des versions

Justine le 3 novembre 2022 à 09:18