There should be a shorthand for `foo: ref foo` in struct field patterns.

[jld]

In a pattern matching a struct (or struct-like enum variant), a field can be bound to a variable of the same name by using Thing { foo, ... } as a shorthand for Thing { foo: foo, ... }. It would be nice if there were a similar shorthand for Thing { foo: ref foo, ... }, when the field can't or shouldn't be copied; possibly Thing { ref foo, ... }, unless that's ambiguous.

Not a big issue, but it would help lower the activation energy for using struct-like variants instead staying with tuple-like variants after the point where they need comments in the definition to keep track of which bool/int/whatever means what (comments which are, of course, not available to the type checker).

[huonw]

Visiting for triage: still valid (doesn't parse). A testcase for the proposed feature:

fn main() {
    enum Foo {
        Bar { bar: ~str },
        Baz { baz: int }
    }
    match Bar(~"bar") {
        Bar { ref bar } => { println(*bar) } // should print `bar`
        _ => {}
    }

    let mut baz = Baz { baz: 0 };
    match baz {
        Baz { ref mut baz } => { *baz += 1 }
        _ => {}
    }
    printfln!(baz); // the `baz` field should be 1
}

Nominating for production ready (this is strictly more permissive that the current language, so not a backwards-compat feature).

[graydon]

just a bug, removing milestone/nomination.