Guide: Patterns: use non-x variables in match blocks

[chastell]

I think it helps to show that the variables introduced in match blocks are indeed independent from the matched variable x (especially when x is still reachable inside those blocks and might be useful), so this renames them accordingly. Maybe some linter (or language-level warning?) will eventually warn about shadowing x in such cases. ;)

I’m not super happy about the matching-on-range example, as it’s too contrived (e and x are exactly the same here), but I couldn’t come up with something both simple and non-redundant.

[rust-highfive]

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @nikomatsakis (or someone else) soon.

[steveklabnik]

Hmm, I'm torn about this. Shadowing is something that we tend to do a lot.

[chastell]

Oooh, interesting! Isn’t access to the matched variable in the match block useful sometimes?

(Warning: highly contrived and probably super-unidomatic example ahead; I learned about fmt only now to post this example…)

use std::fmt;

enum OptionalInt {
    Value(int),
    Missing,
}

impl fmt::Show for OptionalInt {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Value(i) => write!(f, "Value({})", i),
            Missing  => write!(f, "Missing"),
        }
    }
}

fn main() {
    let x = Value(6i);

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

[huonw]

It seems to me that we should aim to be as clear as possible by default (I.e. no shadowing), and possibly mention shadowing explicitly. FWIW, I don't think shadowing between the match head and subbindings is that common, normally plain locals.

[steveklabnik]

@huonw fair enough! I'm fine with giving this an r+ if you are

[nikomatsakis]

I agree with @huonw