IOpNegatable: Cannot perform binary operation '-' about beef HOT 3 CLOSED

But, yes- @Ruzihm did find a different issue- there are not good error messages for attempting to invoke an operator overload dynamically from an interface. These interfaces were meant only to be used as generic constraints, not for dynamic dispatch.

The issue is that the return type from these operator overloads is 'Self'. This is not allowed since 'Self' infers the type implementing this interface (the concrete type). If you are dynamically calling a Self-returning interface method on a boxed valuetype, then that return value would have to be boxed by the callee --- which I thought I couldn't allow since it infers heap allocation that no one will know to clean up, but now I realize it COULD be implemented with a side stack.

So, better error message for now, but dynamic dispatch for operator overloads is going in the "future features" pile - but with a fairly low priority.

from beef.

Shouldn't it rather be a different interface such as IOpSubtractable ? IOpNegatable specifically defines the unary negate operator, e.g.:

IOpNegatable x = (Float)5.0;
IOpNegatable y = -x;

Console.Write("{}", (Float)y);

Which... actually doesn't even compile because "Operator can only be used on numeric types". What's with that?

But this works as expected:

using System;

namespace Program
{
	class Foobar : IOpNegatable
	{
		public int value;

		public this(int val)
		{
			value = val;
		}

		public static Self operator -(Self me)
		{
			let result = new Foobar();
			result.value = -me.value;
			return result;
		}

		override public void ToString(String strBuffer)
		{
			strBuffer..AppendF("{}",value);
		}
	}

    class Program
    {
        public static void Main()
        {
           	Foobar x = scope:: Foobar(5);

		Foobar y = -x;
                defer delete y;

		Console.Write("{}", y);

		Console.In.Read();

        }
    }
}

from beef.

Agreed after giving a bit more thought a new interface IOpSubtractable is the correct approach

from beef.