Match destructuring in alternations should be generic over types

[mdinger]

#![feature(globs)]

use Char::*;

enum Char {
    A(int),
    B(i32),
    C(char),
}
fn main(){ 
    let a = Char::A(7);

    // This match doesn't work because `x` changes type inside
    // one arm. The compiler should take this and generate an
    // equivalent of the second `match` example.
    match a {
        A(x) | B(x) | C(x) => println!("{}", x),
    }

    // This works because `x` doesn't change type inside an arm.
    match a {
        A(x) => println!("{}", x),
        B(x) => println!("{}", x),
        C(x) => println!("{}", x),
    }

}

[zwarich]

This requires inferring a trait bound on x, and there may be multiple choices depending on the methods called.

[mdinger]

Does that mean it's unworkable or just more complicated than it looks?

[zwarich]

@mdinger The choice most consistent with the rest of the language would be to require the trait bound to be manually specified.

[mdinger]

I guess I don't see how it could matter. But okay. Does this mean I need to close this?

[glaebhoerl]

A way I think this could work is if we had first-class existential types, and then the most general type of x on the LHS in the first example could be inferred as exists T: Show. T or similar (having a single variable x with three different, unrelated types int, i32, and char at the same time is clearly unworkable), from which it then logically follows that it can only be consumed by a suitably polymorphic function (as on the RHS).

But sadly even the only paper I know of which proposes first-class existentials doesn't infer them, but requires a type annotation to introduce one, so this doesn't seem very realistic.

(Maybe union types could also do it? I know even less about those.)