Imagine a language which doesn't allow multiple value constructors for a data type. Instead of writing

```
data Color = White | Black | Blue

```

we would have

```
data White = White
data Black = Black
data Blue = Black
type Color = White :|: Black :|: Blue

```

where `:|:` (here it's not `|` to avoid confusion with sum types) is a built-in type union operator. Pattern matching would work in the same way

```
show :: Color -> String
show White = "white"
show Black = "black"
show Blue = "blue"

```

As you can see, in contrast to coproducts it results in a flat structure so you don't have to deal with injections. And, unlike sum types, it allows to randomly combine types resulting in greater flexibility and granularity:

```
type ColorsStartingWithB = Black :|: Blue

```

I believe it wouldn't be a problem to construct recursive data types as well

```
data Nil = Nil
data Cons a = Cons a (List a)
type List a = Cons a :|: Nil

```

I know union types are present in TypeScript and probably other languages, but why did the Haskell committee chose ADTs over them?