[Proposal]Allow implicit calling operator overloading in interface

[huoshan12345]

Now an operator overloading can be defined in interface like this:

public interface IService
{
    public static IService operator +(IService a, IService b)
    {
        throw new NotImplementedException();
    }
}
public class Service : IService { }

And can be called like this:

IService a = new Service();
IService b = new Service();
var c = a + b;
Assert.Equal(3, c.Count);

OR

var a = new Service();
IService b = new Service();
var c = a + b;

OR

IService a = new Service();
var b = new Service();
var c = a + b;

However, the operator overloading in interface has to be called by interface explicitly which means it cannot be called like this:

var a = new Service();
var b = new Service();
var c = a + b; // not legal

It would be great if I could do the above.

[iam3yal]

@huoshan12345 This seems wrong but my opinions aside, DIM was consciously designed such that it isn't part of the contract of the type so it wouldn't break source or binary compatibility so in this case you might want to use an abstract class as opposed to an interface.

[huoshan12345]

@eyalsk I would like to apply it for a struct as well, which cannot inherit from an abstract class.
Actually I prefer this:

public static IService operator +<T>(T a, IService b) 
where T : IService
// Defined in an interface

OR

public static IService operator +(this T a, IService b) 
where T : IService
// Defined like an extension method

However it seems to be much more difficult to implement any of them.
So I created the original proposal.

[iam3yal]

@huoshan12345 Why can't you do something like this?

void Main()
{
	var a = new ServiceA();
	var b = new ServiceB();
	var c = a.Add(b);
}

interface IService
{
	IService Execute();
}

class ServiceA : IService
{
	public IService Execute()
	{
		Console.WriteLine(typeof(ServiceA));
		
		return this;
	}
}

struct ServiceB : IService
{
	public IService Execute()
	{
		Console.WriteLine(typeof(ServiceB));
		
		return this;
	}
}

struct ServiceComposer  : IService
{
	private IService _a;
	private IService _b;
	
	public ServiceComposer(IService a, IService b)
	{
		_a = a;
		_b = b;
	}
	
	public IService Execute()
	{
		Console.WriteLine(typeof(ServiceComposer));
		
		_a.Execute();
		_b.Execute();
		
		return this;
	}
}

static class IServiceExtensions
{
	public static IService Add(this IService a, IService b) => new ServiceComposer(a, b);
}

Maybe even change Execute to something like this:

public IService Execute()
{
    Console.WriteLine(typeof(ServiceComposer));
    
    return _a.Execute().Add(_b.Execute());
}

I'm not sure what you want to do with this but yeah, I think that this is much better than a language change.

[huoshan12345]

@eyalsk extension method is great and it can totally serve my purpose
But sometimes it will be more readable if I use an operator in my opition.
Think about this a.Add(b).Add(c).Add(d) vs a + b + c + d or a = a.Add(b) vs a += b

[iam3yal]

@huoshan12345 I understand what you're saying but given the community discussions we had about DIM and the design goals for it I doubt the LDT would change their minds about it but like always I could be wrong. 😄

But sometimes it will be more readable if I use an operator in my opition.

You're violating the design guidelines for operator overloading but more importantly I really don't think it's more readable because I don't really know what adding a service means whereas I do know what adding one number to another would mean.

[huoshan12345]

@eyalsk

I understand what you're saying but given the community discussions we had about DIM and the design goals for it I doubt the LDT would change their minds about it.

I agree with you. 😅

You're violating the design guidelines for operator overloading but more importantly I really don't think it's more readable because I don't really know what adding a service means whereas I do know what adding one number to another would mean.

Service may be a bad name as an example.
It may be more understandable if it is changed to:

public interface INumber
{
    public INumber Add(INumber a);
    public static INumber operator +(INumber a, INumber b) => a.Add(b);
}

public readonly struct Integer : INumber
{
    private readonly int _inner;

    public Integer(int inner)
    {
        _inner = inner;
    }

    public INumber Add(INumber a) => a switch
    {
        Integer integer => new Integer(_inner + integer),
        MixedFraction mixedFraction => mixedFraction + this,
        _ => throw new ArgumentOutOfRangeException(nameof(a))
    };

    public static Integer operator +(Integer integer, int i)
    {
        return new Integer(integer._inner + i);
    }
    public static implicit operator int(Integer integer)
    {
        return integer._inner;
    }
}

public readonly struct MixedFraction : INumber
{
    private readonly int _integer;
    private readonly int _numerator;
    private readonly int _denominator;

    public MixedFraction(int integer, int numerator, int denominator)
    {
        _integer = integer;
        _numerator = numerator;
        _denominator = denominator;
    }

    public static MixedFraction operator +(MixedFraction left, MixedFraction right)
    {
        throw new NotImplementedException();
    }

    public static INumber operator +(MixedFraction left, Integer right)
    {
        return new MixedFraction(left._integer + right, left._numerator, left._denominator).TrySimplify();
    }

    public INumber TrySimplify()
    {
        // a MixedFraction may be simplified to an Integer
        throw new NotImplementedException();
    }

    public INumber Add(INumber a) => a switch
    {
        Integer integer => this + integer,
        MixedFraction mixedFraction => this + mixedFraction,
        _ => throw new ArgumentOutOfRangeException(nameof(a))
    };
}

And I would like to call like this:

var a = new Integer(1);
var b = new MixedFraction(1, 1, 3);
var c = a + b; // not legal
var d = b + a; // legal

[iam3yal]

@huoshan12345 Yes this makes more sense; however, in C# 10 we gonna have something called Shapes/Roles or something similar (hopefully!) #164/#1711 which is tracked here #110 that would allow you to do things over types in a more general way so you could do exactly what you want and more, for example with shapes, you could define a shape say SNumber which will be used as a generic constraint on MixedFraction and then operate on any T which is a number not just an integer as a benefit you wouldn't have to abstract existing types to make it work.