[valenterry]

Well, that depends. If the union consists of two types that share the same underlying structure, then obviously at runtime we can never know what the value is.

But otherwise we can. And this is something that we will know at compile-time, so we can prevent runtime-checks that would not work.

[insanitybit]

I must not be understanding what you're asking for because it sounds like anonymous sum types.

[valenterry]

Maybe this is just about terminology.

But essentially, when it comes to union types, they behave like sets. The compiler merges them. (A | B) | (A | B) is the same as A | B. But for sum types (even anonymous ones such as tuples) the compiler can't merge them because that would lose information (if the result is from the first A | B or the second one). Instead, you end up with a nested structure.

Which one is desired depends on the use-case, but it's definitely different.

[wtetzner]

The problem is that if you have e.g.

    let x: u64|i32 = ...

It's impossible for the compiler to do anything with x without adding some kind of runtime type tag. The representations of those types are different.

But with something like OCaml's polymorphic variants, you could do e.g.

    let x: Big(u64)|Small(i32) = ...

and then switch on the tag (Big or Small) to determine what to do with the values.

[valenterry]

> It's impossible for the compiler to do anything with x without adding some kind of runtime type tag.

Yes, in this particular case that's true. If the developer tries to do anything except maybe printing it for debug then the compiler will tell the developer so and the developer will have to switch to sumtypes / wrap it just like it is done in OCaml by default.