C# Roles/IMonoid<T>

[wilbennett]

I'm not sure if this is the correct place to put this. I did a search here and it came up with some meeting notes on roles which is why I'm asking here.

I watched an NDC Video - 43:51 of Mads Torgersen discussing the future implementation of Roles/IMonoid/Extension methods. I do not agree with the proposed implementation/use of IMonoid. I feel it is unnecessarily limiting in capabilities or maybe I'm just misunderstanding.

Let's start with the example given:

interface IMonoid<T>
{
    static T Zero { get; }
    static T operator +(T t1, T t2);
}

public static T AddAll<T>(T[] ts) where T : IMonoid<T>
{
    T result = T.Zero;
    foreach (T t in ts) { result += t; }
    return result;
}

role IntAddMonoid extends int : IMonoid<int>
{
    public static int Zero => 0;
}

role IntMulMonoid extends int : IMonoid<int>
{
    public static int Zero => 1;
    public static int operator +(int x, int y) => x * y;
}

int sixtyThree = AddAll<IntAddMonoid>(new [] { 1, 2, 4, 8, 16, 32 });
int thirtyTowThousandSevenHundredAndSixtyEight = AddAll<IntMulMonoid>(new [] { 1, 2, 4, 8, 16, 32 });

Now this is where I may be misunderstanding but my take away from this is:

• Only one IMonoid implementation can be "active" at a time
• Calling a method AddAll but doing multiplication is confusing (Yes, I know it's just a demo and this would be the "Reduce" method but inside, "+" is being translated into "*")

One of the ways I would want to use this is as follows:

class Vec2<T> where T : IMonoid<T>
{
    public T X { get; }
    public T Y { get; }

    public T Cross(other: Vec2<T>) // or Wedge/PerpProduct for 2D
    {
        return X * other.Y - Y * other.X;
    }
}

I would need the "*" and "-" role/monoids to be active at the same time. Am I missing something?

If not, I think an approach like what F# uses would be better.

type INumeric<'T> =
    abstract Zero: 'T
    abstract One: 'T
    abstract Add: 'T * 'T -> 'T
    abstract Subtract: 'T * 'T -> 'T
    abstract Multiply: 'T * 'T -> 'T
    abstract Negate: 'T -> 'T
    abstract Sign: 'T -> int
    abstract Abs: 'T -> 'T
    abstract Equals: 'T * 'T -> bool
    abstract Compare: 'T * 'T -> int
    abstract ToString: 'T * string * System.IFormatProvider -> string
    abstract Parse: string * Globalization.NumberStyles * System.IFormatProvider -> 'T

// Which in C# would be:

interface INumeric<T>
{
    static T Zero { get; }
    static T One { get; }
    static T operator +(T t1, T t2);
    static T operator -(T t1, T t2);
    static T operator *(T t1, T t2);
    ...
}

[HaloFour]

The discussion is not about an implementation of IMonoid<T>, it's about the language and runtime features to enable the implementation of IMonoid<T> and any other flavor of type class or shape. The features would almost certainly enable a "numeric" shape as you've described to enable generic math functions.

See: #1711 and #164

[wilbennett]

Thanks @HaloFour! I guess I'll just wait to see how this shakes out then.

[wilbennett]

BTW I'm a big fan of the extension everything and roles ideas. Looking forward to using those.