Compile-time constants for C# 10 generic math interfaces?

[dcuccia]

Hi!

I'm enjoying playing with the new math generics introduced in .Net 6 Preview 7, and wondering if there is a possibility to support compile-time constants such as T.One, T.Zero, etc. I was prototyping some math helpers and ran into this issue when trying to combine with switch expressions. For example:

Result<T> MaybeInverse<T>(T number) where T : INumber<T>, IDivisionOperators<T, T, T>
    => number switch
    {
        T.Zero => new Error("Can't divide a number by zero."), // won't compile, as T.Zero is not compile-time constant
        _      => T.MultiplicativeIdentity / number
    };

class Error
{
    public Error(string message) => Message = message;
    public string Message { get; init; }
    public override string ToString() => Message;
}

class Result<T> : Choice<T, Error>
{
    public static implicit operator Result<T>(T value) => new Result<T>(value);
    public static implicit operator Result<T>(Error error) => new Result<T>(error);

    public Result(T item) : base(item) { }
    public Result(Error item) : base(item) { }
}

class Choice<A, B> // Union type
{
    public Choice(A item) { Item = item!; }
    public Choice(B item) { Item = item!; }

    public dynamic Item { get; }
}

If this is helpful as a ticket, please let me know and I'll create one. @tannergooding

Thanks!
David

[alexrp]

This isn't really possible, partially due to how constant fields work in the runtime and partially due to how the compiler consumes them.

A special pattern syntax allowing matching against non-constants is probably a more feasible ask.

[dcuccia]

I see. Is the pattern syntax approach something that is possible with the compiler today?