Rust by Example - страница 21
>
>// and you can also ignore some variables:
>Foo { y, .. } => println!("y = {}, we don't care about x", y),
>// this will give an error: pattern does not mention field `x`
>//Foo { y } => println!("y = {}", y),
>}
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
A match guard can be added to filter the arm.
>fn main() {
>let pair = (2, -2);
>// TODO ^ Try different values for `pair`
>println!("Tell me about {:?}", pair);
>match pair {
>(x, y) if x == y => println!("These are twins"),
>// The ^ `if condition` part is a guard
>(x, y) if x + y == 0 => println!("Antimatter, kaboom!"),
>(x, _) if x % 2 == 1 => println!("The first one is odd"),
>_ => println!("No correlation..."),
>}
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Note that the compiler does not check arbitrary expressions for whether all possible conditions have been checked. Therefore, you must use the _ pattern at the end.
>fn main() {
>let number: u8 = 4;
>match number {
>i if i == 0 => println!("Zero"),
>i if i > 0 => println!("Greater than zero"),
>_ => println!("Fell through"), // This should not be possible to reach
>}
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Indirectly accessing a variable makes it impossible to branch and use that variable without re-binding. match provides the @ sigil for binding values to names:
>// A function `age` which returns a `u32`.
>fn age() -> u32 {
>15
>}
>fn main() {
>println!("Tell me what type of person you are");
>match age() {
>0 => println!("I haven't celebrated my first birthday yet"),
>// Could `match` 1 ..= 12 directly but then what age
>// would the child be? Instead, bind to `n` for the
>// sequence of 1 ..= 12. Now the age can be reported.
>n @ 1 ..= 12 => println!("I'm a child of age {:?}", n),
>n @ 13 ..= 19 => println!("I'm a teen of age {:?}", n),
>// Nothing bound. Return the result.
>n => println!("I'm an old person of age {:?}", n),
>}
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
You can also use binding to "destructure" enum variants, such as Option:
>fn some_number() -> Option
>Some(42)
>}
>fn main() {
>match some_number() {
>// Got `Some` variant, match if its value, bound to `n`,
>// is equal to 42.