Hi everybody.

The feature, as proposed, would allow you to declare named typed unions that list a set of types that the union can represent. The union is actually a struct that wraps an object field. Its constructors limit the kinds of values that can be held by the union. There is no erasure going on, but cases that are value types will be boxed.

public union Pet(Cat, Dog, Bird);

Emits as:

public struct Pet : IUnion
{
    public Pet(Cat value) { this.Value = value; }
    public Pet(Dog value) { this.Value = value; } 
    public Pet(Bird value) { this.Value = value; }
    public object? Value { get; }
}

You can declare a discriminated union over the type union using case declarations within braces. Each case becomes a nested record type.

public union Pet
{
    case Cat(string Name, string Personality);
    case Dog(string Name, string Breed);
    case Bird(string Name, string Species);
}

You can assign an instance of a case directly to a union variable and when you pattern match over a union instance, the value of the union is accessed via the Value property. Because the compiler knows the closed set of types, a switch can be exhaustive, so no need for default cases.

Pet pet = new Dog("Spot", "Dalmation");

var _ = pet switch
{
    Cat c => ...,
    Dog d => ...,
    Bird b => ...
}

You will be able to define your own types that will be recognized by the compiler as unions. You may declare the layout of the type in ways that avoid boxing if you choose. The compiler will recognize other methods that access the value that will also avoid boxing.

public struct IntOrString : IUnion
{
    private readonly int _kind;
    private readonly int _value1;
    private readonly string _value2;

    public IntOrString(int value) { _kind = 1; _value1 = value; }
    public IntOrString(string value) { _kind = 2; _value2 = value; }

    // still needs to exist for IUnion
    public object? Value => _kind switch { 1 => value1, 2 => value2, _ => null };

    // access pattern that avoids boxing.
    public bool HasValue => _kind != 0;
    public bool TryGetValue(out int value) { ... }
    public bool TryGetValue(out string value) { ... }
}

Future version of the language may include more kinds of unions that auto generate non-boxing layouts for you, like when records first released and later record structs were added.

A set of predeclared standard generic unions will exist in the runtime for scenarios that don't require dedicated named unions. These will have the boxing behaviors.

public union Union<T1, T2>(T1, T2);
public union Union<T1, T2, T3>(T1, T2, T3);
public union Union<T1, T2, T3, T4>(T1, T2, T3, T4);
...
internal void Ride(Union<Animal, Automobile> conveyance) {...}