Given the types T1 and T2, the union type `U = T1 | T2` includes all values of type T1 and values of type T2.
A tagged union on the other hand is a new type which does not accept values of neither T1 nor T2 without tagging them with their appropriate tag.
Would there be any benefit for Tagged Unions over "non-tagged" Unions?
Nullable<T> is an untagged union between T and None.
- Their values can be discriminated at runtime (it's depending on the implementation of union types whether that's possible. In C a union is just a structure large enough to hold all constituents)
- You can sum the same type (union(Int, Int) simply is Int)
- The tag breaks recursion. You can build recursive sum types because of it, e.g. 'a List = Empty | Cons('a, 'a List)
I'm not sure this is the case. In some cases Union(Int, Int) might be interpreted as a union of Left-Int or Right-Int
Then again, my understanding of sum vs union might not be overly precise :-)
edit: s/now/not/
type Option a = Some a | None # here Some and None are tags, not types themselves
type Some a # a wrapper type for an a
type None # a unit type
type Option a = Some a | None
But the more typical use case for untagged unions is different: given a type such as
type StringOrInt = String | Int
So (untagged) Union-type of Haskell really (almost) means INTERSECTION.
But it is not an intersection in set-theoretic sense if we think of the values as elements of the sets, because it allows values of both types, but you can only use an intersection of the APIs they provide.