rust/src/doc/trpl/patterns.md

% Patterns

We've made use of patterns a few times in the guide: first with let bindings, then with match statements. Let's go on a whirlwind tour of all of the things patterns can do!

A quick refresher: you can match against literals directly, and _ acts as an any case:

let x = 1i;

match x {
    1 => println!("one"),
    2 => println!("two"),
    3 => println!("three"),
    _ => println!("anything"),
}

You can match multiple patterns with |:

let x = 1i;

match x {
    1 | 2 => println!("one or two"),
    3 => println!("three"),
    _ => println!("anything"),
}

You can match a range of values with ...:

let x = 1i;

match x {
    1 ... 5 => println!("one through five"),
    _ => println!("anything"),
}

Ranges are mostly used with integers and single characters.

If you're matching multiple things, via a | or a ..., you can bind the value to a name with @:

let x = 1i;

match x {
    e @ 1 ... 5 => println!("got a range element {}", e),
    _ => println!("anything"),
}

If you're matching on an enum which has variants, you can use .. to ignore the value and type in the variant:

enum OptionalInt {
    Value(int),
    Missing,
}

let x = OptionalInt::Value(5i);

match x {
    OptionalInt::Value(..) => println!("Got an int!"),
    OptionalInt::Missing   => println!("No such luck."),
}

You can introduce match guards with if:

enum OptionalInt {
    Value(int),
    Missing,
}

let x = OptionalInt::Value(5i);

match x {
    OptionalInt::Value(i) if i > 5 => println!("Got an int bigger than five!"),
    OptionalInt::Value(..) => println!("Got an int!"),
    OptionalInt::Missing   => println!("No such luck."),
}

If you're matching on a pointer, you can use the same syntax as you declared it with. First, &:

let x = &5i;

match x {
    &val => println!("Got a value: {}", val),
}

Here, the val inside the match has type int. In other words, the left-hand side of the pattern destructures the value. If we have &5i, then in &val, val would be 5i.

If you want to get a reference, use the ref keyword:

let x = 5i;

match x {
    ref r => println!("Got a reference to {}", r),
}

Here, the r inside the match has the type &int. In other words, the ref keyword creates a reference, for use in the pattern. If you need a mutable reference, ref mut will work in the same way:

let mut x = 5i;

match x {
    ref mut mr => println!("Got a mutable reference to {}", mr),
}

If you have a struct, you can destructure it inside of a pattern:

# #![allow(non_shorthand_field_patterns)]
struct Point {
    x: int,
    y: int,
}

let origin = Point { x: 0i, y: 0i };

match origin {
    Point { x: x, y: y } => println!("({},{})", x, y),
}

If we only care about some of the values, we don't have to give them all names:

# #![allow(non_shorthand_field_patterns)]
struct Point {
    x: int,
    y: int,
}

let origin = Point { x: 0i, y: 0i };

match origin {
    Point { x: x, .. } => println!("x is {}", x),
}

You can do this kind of match on any member, not just the first:

# #![allow(non_shorthand_field_patterns)]
struct Point {
    x: int,
    y: int,
}

let origin = Point { x: 0i, y: 0i };

match origin {
    Point { y: y, .. } => println!("y is {}", y),
}

If you want to match against a slice or array, you can use []:

fn main() {
    let v = vec!["match_this", "1"];

    match v.as_slice() {
        ["match_this", second] => println!("The second element is {}", second),
        _ => {},
    }
}

Whew! That's a lot of different ways to match things, and they can all be mixed and matched, depending on what you're doing:

match x {
    Foo { x: Some(ref name), y: None } => ...
}

Patterns are very powerful. Make good use of them.