Rust by Example | страница 35

>// 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.

>Some(n @ 42) => println!("The Answer: {}!", n),

>// Match any other number.

>Some(n) => println!("Not interesting... {}", n),

>// Match anything else (`None` variant).

>_ => (),

>}

>}

>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

For some use cases, when matching enums, match is awkward. For example:

>#![allow(unused)]

>fn main() {

>// Make `optional` of type `Option`

>let optional = Some(7);

>match optional {

>Some(i) => {

>println!("This is a really long string and `{:?}`", i);

>// ^ Needed 2 indentations just so we could destructure

>// `i` from the option.

>},

>_ => {},

>// ^ Required because `match` is exhaustive. Doesn't it seem

>// like wasted space?

>};

>}

if let is cleaner for this use case and in addition allows various failure options to be specified:

>fn main() {

>// All have type `Option`

>let number = Some(7);