Proposal: Generic types should support operators

[scottdorman]

Copied from dotnet/roslyn#2147

C# is limited by the support for generic constraints offered by the CLR which only really supports class, struct, new(), a subclass and/or a list of interfaces.

Generic types should support operators, allowing code similar to:

public static T GenericAdd(T a, T b)
{
   return a + b + 100;
}

[iam3yal]

@scottdorman :)

public static T GenericAdd(T a, T b) where T: number
{
   return a + b + 100;
}

A proposal for artificial number type might be quite useful in this case and maybe other cases.

I don't know what it means yet but just a thought.

[gafter]

The championed proposal #110 would provide a way to do this.

[scottdorman]

@eyalsk Yes, that's a better syntax than what I wrote. :)

@gafter I looked for a proposal that would address this but didn't see one. If implementing #110 provides this feature, then I'm good to close this in favor of that proposal.

[iam3yal]

@scottdorman Yes it does solve this, you can actually create a Number<T> as your concept and then implement it as an instance but it's slightly more involved than doing where T: number.

[scottdorman]

@eyalsk Thanks for that clarification. So doing that would allow us to do it but means we have to do a lot of extra work. In that case, I'm in favor of keeping this proposal since I think the syntax of using where T: number is much more concise and more appropriate for implementing operator support.

[iam3yal]

@scottdorman Well I guess that there's some more design work so I'm not sure whether we will have to do a lot of extra work, also, if this feature is going to be implemented they can always introduce number as syntactic sugar for Number<T>, I'm not sure what would be the value of this but it's a possibility.

[scottdorman]

they can always introduce number as syntactic sugar for Number.

That would only work if introducing that syntax sugar also carried with it any work that needs to be done to support generic operators.

I guess until we know how much extra work might be required for us, as the consumers of the feature, and how many times we'll have to rewrite that work in each of the various projects we might need to use this feature, I'm inclined to leave this request open.

[orthoxerox]

I think that the issue name is not 100% clear. Generic types already support operators (as long as the operators themselves don't introduce new generic parameters themselves). It's generic type parameters that should support support operators.

I am not sure if #110 will support operators directly. Current proposal draft doesn't provide any syntax sugar for operators.

[iam3yal]

@orthoxerox Well, depends how you look at it, I mean instances will have to be specific as far as I can tell but it makes a lot of sense in a type safe language, what would the operator plus or multiplication would mean for a generic type?

[gafter]

As we work on #110 we intend to permit the compiler to infer everything possible rather than require the programmer to spell it out (e.g. that unless otherwise specified, the + operator to be used on int is int operator +(int, int)).

[scottdorman]

@orthoxerox, @eyalsk The title was copied from the initial proposal in the Roslyn repo. For me, the goal is to be able to write code like this:

public static T Between(this T expression, T min, T max) where T: number
{
   return expression > minimum && expression < maximum;
} 

Right now, I can do something similar but it requires separate methods for each of the numeric types. If I want to reduce the amount of duplicated code, I can use a private method that makes use of an IComparer<T> instance but it's still a bit of a pain.

[gafter]

See https://github.com/MattWindsor91/roslyn/blob/master/concepts/docs/csconcepts.md#sugar-operator-overloading for operator overloading in the "concepts" proposal.

[scottdorman]

@gafter

As we work on #110 we intend to permit the compiler to infer everything possible rather than require the programmer to spell it out (e.g. that unless otherwise specified, the + operator to be used on int is int operator +(int, int)).

In that case, I think it would allow me to do what I showed in my earlier comment.

[iam3yal]

@gafter Pretty cool, thanks. :)

[TobiasKnauss]

@scottdorman

public static T Between(this T expression, T min, T max) where T: number
{
   return expression > minimum && expression < maximum;
} 

is possible already:

    //--------------------------------------------------------------------------
    // Compare
    //
    // compare generic elements.
    // https://msdn.microsoft.com/de-de/library/2y07t0wt(v=vs.110).aspx
    // value  meaning
    //  < 0   i_tValue1 is less than i_tValue2.
    // == 0   i_tValue1 equals i_tValue2.
    //  > 0   i_tValue1 is greater than i_tValue2.
    //--------------------------------------------------------------------------
    public static int Compare<T> (T i_tValue1, T i_tValue2)
    {
      return Comparer<T>.Default.Compare (i_tValue1, i_tValue2);
    }

I'm using that in many generic functions. You can easily add that into your Between().

But I also need generic operators, or "operator" constraints to generic types, or a "numerical" constraint to generic types, well, anything that would limit T to [byte, sbyte, ushort, short, uint, int, ulong, long, float, double, BigInt, Decimal], which actually are all types that you can do calculations with.

[jnm2]

@TobiasKnauss You'd be interested in #1711, then.