when multiple union fields share the same type, allow them to share a body in a switch prong

[andrewrk]

const Foo = union(enum) {
 One: i32,
 Two: bool,
 Three: i32,
};
fn bar(f: Foo) void {
 switch (f) {
 Foo.One, Foo.Three => |x| { },
 Foo.Two => |b| { },
 }
}

[PavelVozenilek]

It should be possible to omit the Foo prefix. There's no ambiguity.

---

And if the unioned types are unique, I may prefer to use them:

const Foo = union(enum) {
 One: i32,
 Two: bool,
 Three: u32,
};
fn bar(f: Foo) void {
 switch (f) {
 u32, i32=> |x| { },
 bool => |b| { },
 }
}

[andrewrk]

It should be possible to omit the Foo prefix. There's no ambiguity.

#683

[shritesh]

The above behavior works now but there might be a soundness issue here as the following works too:

const Foo = union(enum) {
 One: i32,
 Two: bool,
 Three: i32,
};

fn bar(f: Foo) void {
 switch (f) {
 .One, .Two, .Three => |x| {
 @import("std").debug.warn("{}\n", x);
 },
 }
}

test "" {
 bar(Foo{ .One = 21 });
 bar(Foo{ .Two = false });
 bar(Foo{ .Three = -1 });
}

[andrewrk]

Hmm yes that looks like a missing compile error.

[LemonBoy]

The above behavior works now but there might be a soundness issue here as the following works too:

It's not unsound, x is not the payload but f, it's just...weird?

[shritesh]

Yeah. The type of x becomes Foo when more than one cases are specified.

[hryx]

x is not the payload but f

This has bitten me before. When I see |x|, I always expect it to unwrap something. So in this case I would not expect x to be the same type as f. Not to mention that the behavior of "|x| unwraps, unless the case's tag types don't match" is pretty gnarly.

[emekoi]

then would this not be allowed?

fn bar(f: Foo) void {
 switch (f) {
 .One => |x| {
 @import("std").debug.warn("{}\n", x);
 },
		// tag types don't match
 else => |x| {
 @import("std").debug.warn("{}\n", x);
 },
 }
}

[hryx]

then would this not be allowed?

I would say it should not be allowed, because the else => should have the same effective behavior as .Two, .Three =>.

My intuition is that |x| always unwraps, and to get the original Foo you must use f.