`Foo(..)` patterns work for tuple structs, but `(..)` doesn't work for tuples

[niconii]

Right now, this compiles:

struct Foo(i32, i32, i32);

fn main() {
    match Foo(1, 2, 3) {
        Foo(..) => { }
    }
}

but this fails to compile:

fn main() {
    match (1, 2, 3) {
        // must write `(_, _, _) => { }`
        (..) => { }
    }
}

[petrochenkov]

Yeah, also

struct Foo(i32, i32, i32);

fn main() {
    match Foo(1, 2, 3) {
        Foo(a, ..) => { }
    }
}

doesn't work. .. in patterns has a couple of pretty obvious extensions, someone just need to write an RFC (probably me, at least I was going to do it some time ago).

[durka]

@petrochenkov have to be careful because in

struct Foo(i32, RangeFull);

fn main() {
    match Foo(i32, ..) {
        Foo(a, ..) => { }
    }
}

the .. is not a catchall pattern. So the extensions may lead to confusion/ambiguity. I guess this is already a problem with struct Foo(RangeFull);.

[petrochenkov]

@durka
RangeFull literals .. are not considered patterns, so there's no conflict currently.

[steveklabnik]

Closing in favor of the RFC, since this would be a language change.