Type Unions Syntax & Design Questions

[Panthr75]

I've been mapping out syntax of a separate language I want to make based on C#, and I decided to start mapping out type union syntax, but I have ran into several important design and syntax questions that should be relevant to the Type Unions proposal.

Should Type Unions allow methods/properties/etc?

Due to how big of a question this is, I'll go into more detail plus a potential implementation solution.

Take for example the Option type union:

public union struct Option<TValue>
{
    Some(TValue value);
    None = default;
}

It would be nice to define some helper methods that I generally see implemented in Option based libraries, such as Map, FlatMap, and GetValueOrDefault.

An idea that I have for implementing this is:

1. Change the syntax of the members to be a comma separated list ending with a semicolon instead of a semicolon list
2. Have all members defined in the union declaration can only be
3. All union type members implement said members

For example, Option<TValue> could look like this:

public union struct Option<TValue>
{
    Some(TValue value)
    {
        public override TValue GetValueOrDefault(TValue defaultValue)
        {
            return value;
        }
        public override Option<TTo> Map<TTo>(Func<TValue, TTo> mapper)
        {
            return new Some(mapper(value));
        }
        public override Option<TTo> FlatMap<TTo>(Func<TValue, Option<TTo>> mapper)
        {
            return mapper(value);
        }
    },
    None
    {
        public override TValue GetValueOrDefault(TValue defaultValue)
        {
            return defaultValue;
        }
        public override Option<TTo> Map<TTo>(Func<TValue, TTo> mapper)
        {
            return None;
        }
        public override Option<TTo> FlatMap<TTo>(Func<TValue, Option<TTo>> mapper)
        {
            return None;
        }
    } = default;

    public abstract TValue GetValueOrDefault(TValue defaultValue);
    public abstract Option<TTo> Map<TTo>(Func<TValue, TTo> mapper);
    public abstract Option<TTo> FlatMap<TTo>(Func<TValue, Option<TTo>> mapper);
}

This could then be lowered to:

[Union]
public readonly struct Option<TValue>
{
    public readonly record struct Some(TValue value)
    {
        public TValue GetValueOrDefault(TValue defaultValue)
        {
            return value;
        }
        
        public Option<TTo> Map<TTo>(Func<TValue, TTo> mapper)
        {
            return new Some(mapper(value));
        }
        
        public Option<TTo> FlatMap<TTo>(Func<TValue, Option<TTo>> mapper)
        {
            return mapper(value);
        }
    }
    public readonly record struct None
    {
        public TValue GetValueOrDefault(TValue defaultValue)
        {
            return defaultValue;
        }
        
        public Option<TTo> Map<TTo>(Func<TValue, TTo> mapper)
        {
            return Option<TTo>.None.Singleton;
        }
        
        public Option<TTo> FlatMap<TTo>(Func<TValue, Option<TTo>> mapper)
        {
            return Option<TTo>.None.Singleton;
        }
        
        public static readonly None Singleton = default;
    }
    
    public TValue GetValueOrDefault(TValue defaultValue)
    {
        if (this.TryGetSome(out Some some))
        {
            return some.GetValueOrDefault(defaultValue);
        }
        else if (this.TryGetNone(out None none))
        {
            return none.GetValueOrDefault(defaultValue);
        }
        else
            throw new InvalidOperationException();
    }
    
    public Option<TTo> Map<TTo>(Func<TValue, TTo> mapper)
    {
        if (this.TryGetSome(out Some some))
        {
            return some.Map(mapper);
        }
        else if (this.TryGetNone(out None none))
        {
            return none.Map(mapper);
        }
        else
            throw new InvalidOperationException();
    }
    
    public Option<TTo> FlatMap<TTo>(Func<TValue, Option<TTo>> mapper)
    {
        if (this.TryGetSome(out Some some))
        {
            return some.FlatMap(mapper);
        }
        else if (this.TryGetNone(out None none))
        {
            return none.FlatMap(mapper);
        }
        else
            throw new InvalidOperationException();
    }
    
    public static implicit operator Option<TValue>(Some value) {...};
    public static implicit operator Option<TValue>(None value) {...};

    public static explicit operator Some(Option<TValue> union) {...};
    public static explicit operator None(Option<TValue> union) {...};

    public bool TryGetSome(out Some value) {...};
    public bool TryGetNone(out None value) {...};

    public enum UnionKind { None = 0, Some = 1 };
    public UnionKind Kind => {...};
}

If Option<TValue> was a regular/class union, it would be lowered to this:

[Closed]
public abstract class Option<TValue>
{
    public sealed record class Some(TValue value) : Option<TValue>
    {
        public override TValue GetValueOrDefault(TValue defaultValue)
        {
            return value;
        }
        
        public override Option<TTo> Map<TTo>(Func<TValue, TTo> mapper)
        {
            return new Some(mapper(value));
        }
        
        public override Option<TTo> FlatMap<TTo>(Func<TValue, Option<TTo>> mapper)
        {
            return mapper(value);
        }
    }
    public sealed record class None : Option<TValue>
    {
        public override TValue GetValueOrDefault(TValue defaultValue)
        {
            return defaultValue;
        }
        
        public override Option<TTo> Map<TTo>(Func<TValue, TTo> mapper)
        {
            return Option<TTo>.None.Singleton;
        }
        
        public override Option<TTo> FlatMap<TTo>(Func<TValue, Option<TTo>> mapper)
        {
            return Option<TTo>.None.Singleton;
        }
        
        public static readonly None Singleton = new();
    }
    
    public abstract TValue GetValueOrDefault(TValue defaultValue);
    
    public abstract Option<TTo> Map<TTo>(Func<TValue, TTo> mapper);
    
    public abstract Option<TTo> FlatMap<TTo>(Func<TValue, Option<TTo>> mapper);
}

Based on the above implementation, it makes it seem like each type member of a Type Union is defined like a record. As such, Would it make sense to allow for Type Union Type Members to define custom constructors?

And finally, Should Type Unions be allowed to implement interfaces?

I hope these questions can help forward the Type Union proposal by answering some important questions.

[HaloFour]

I do think that unions should be able to declare members. However, as struct unions would not be implemented as a type hierarchy I don't think it makes sense for the compiler to pretend that they do. It would complicate the feature both for the developer and for the compiler.

public struct union Option<T> {
    // cases
    None,
    Some(T value);

    // members
    public Option<TTo> Select<TTo>(Func<T, TTo> mapper) {
        return this switch {
            Some(var value) => Some(mapper(value)),
            None => None
        };
    }
}

[Panthr75]

Would this be the same syntax for Class Type Unions?

[HaloFour]

I think it could work for both.

For class type unions, given they are an actual type hierarchy, you could make the case that each case could have its own members, etc. I think it increases the complexity for little gain, personally.

[Panthr75]

How complex could that be? Especially if the method wasn't a simple return switch expression?