@-pattern documentation in the book is a little misleading

[huonw]

http://doc.rust-lang.org/book/patterns.html#bindings . Current text here for future triage purposes:

Bindings

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

let x = 1;

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

This prints got a range element 1.

The @ binding is more general than just | or ... patterns: it can be attached to literally any pattern, e.g.

let mut x: Option<SomeStruct> = ...;
match x {
    Some(SomeStruct { a_field: ref a @ Some(_), .. }) => {}
    Some(ref mut b @ SomeStruct { something_else: 5, .. }) => {},
    Some(SomeStruct { third_one: c @ &Ok(_) }) => {},
    _ => {}
}

Also, for |, the @ has to be attached to each alternative:

let x = 1;
match x {
    y @ 1...5 | y @ 10...15 => println!("{}", y),
    _ => {}
}

[pnkfelix]

Or at least, the identifier y has to be bound in each alternative:

fn main() {
    #[derive(Debug)]
    struct Recur<'a>(u8, Option<&'a Recur<'a>>);
    let r1 = Recur(2, None);
    let r2 = Recur(1, Some(&r1));
    match r2 {
        ref y @ Recur(1, _) | Recur(_, Some(&ref y)) => {
            println!("{:?}", y);
        }
        _ => { println!("other"); }
    }
}