[Proposal] Operator overloading on Interfaces

[stefc]

I really want to see that I can use operator overloading also on Interfaces.

For example I've an interface IVector that have for example the immutable Add method :

IVector Add(IVector operand);

instead of
IVector x = a.Add(b);

I want to write
IVector x = a + b;

I don't see any reason why operator overloading is restricted to work only on normal classes.

[AlgorithmsAreCool]

How would we define this operator? Typically they are in static methods in a class. Would you propose to allow static methods on interface definitions?

[stefc]

I think operator overloading can be defined the same as extension methods, somewhere in a static class besides the interface declaration.

[AlgorithmsAreCool]

Would this change also allow operator definitions for all types from extension methods?

[AlgorithmsAreCool]

See also related discussion

Static interface members
https://roslyn.codeplex.com/discussions/541436

Possibility to provide operators in interface
https://roslyn.codeplex.com/discussions/570704

Static Interfaces Proposal
#2204

[daveaglick]

FYI, there's also related discussion (particularly of static extensions and static interfaces) at #996 and #2204. #112 also looks related, though it's about extension properties and not operators.

[stefc]

I don't see the operator overloading in the context of a static method inside the interface but that the operator overloading can resides somewhere not neccessary in the class/interface itself.
For the sideeffect with an existing operator overloading exsist on the class the compiler should be inform with a warning on that and the developer should be aware of this amigous usage. In my case I use either the interface operators or the class operator, if would define both it would be bad design I think. I see the interface as abstraction of the internals of a class.

[orthoxerox]

@stefc Interfaces as they exist are very, very OOP-ish in their design, defining only virtual methods. Operators, on the other hand, were designed to be non-virtual, probably because C# is a single dispatch language, and it would be confusing to dispatch only on the runtime type of one of the operands.

I'd rather see operators implemented in templates/traits/"enhanced named generic constraints" than try and shoehorn them into interfaces.

[ashmind]

I think this should be done through extension operators -- so it should be covered by #5165 / #4945.

[aluanhaddad]

@ashmind agreed. #5165 is definitely the better proposal.

[gafter]

Issue moved to dotnet/csharplang #516 via ZenHub