Function prototype overloading does not work ?

[vit]

On Wednesday, 19 January 2022 at 08:47:27 UTC, Enjoys Math wrote:
> ```
> module expr;
>
> import dots;
> import operator;
> import equation;
> import var;
> import var_expr;
> import zz_const;
>
> class Expr
> {
> public:
>    void opBinary(string op)(string s) const
>    {
>       static if (op == "+")
>       {
>          Expr right = null;
>
>          if (s == ".." || s == "..." || s == "....")
>          {
>             right = new Dots();
>          }
>
>          if (right !is null)
>             return new Op("+", [this, right]);
>       }
>    }
>
>    override string toString() const
>    {
>       assert(0);
>    }
>
>    Expr sub(Expr x, Expr y)
>    {
>       if (this == x)
>          return y;
>       return this;
>    }
>
>    Expr sub(Expr x, ref Var y)
>    {
>       return sub(x, new VarExpr(y));
>    }
>
>    Expr sub(ref Var x, Expr y)
>    {
>       return sub(new VarExpr(x), y);
>    }
>
>    Expr sub(int x, Expr y)
>    {
>       return sub(ZZ(x), y);
>    }
>
>    Expr sub(Expr x, int y)
>    {
>       return sub(x, ZZ(y));
>    }
>
>    Expr sub(ref Var x, ref Var y)
>    {
>       return sub(new VarExpr(x), new VarExpr(y));
>    }
>
>    Expr sub(ref Var x, int y)
>    {
>       return sub(new VarExpr(x), ZZ(y));
>    }
>
>    Expr sub(int x, ref Var y)
>    {
>       return sub(ZZ(x), new VarExpr(y));
>    }
>
>    override bool opEquals(Object o) {
>       return this is o;
>    }
> }
> ```
> See all the overloads I had to make to sub in order to bypass 
> identity assignment for classes.  I.e. Var can't be of type 
> Expr.  Anyway, this approach is not working because code 
> calling `Expr.sub(int, Var)` is not seeing the definitions.  It 
> says no function matching those args, but clearly there are!

Try replacing methods sub with template:
```d
module expr;

import dots;
import operator;
import equation;
import var;
import var_expr;
import zz_const;

     class Expr
     {
     public:
        void opBinary(string op)(string s) const;

        override string toString() const;

        Expr sub(Expr x, Expr y)
        {
           if (this == x)
              return y;
           return this;
        }

         //template sub:
         Expr sub(T, U)(auto ref T x, auto ref U y){

             //transform parameter to Expr:
             static Expr expr(E)(auto ref E e){
                 static if(is(E : Expr))
                     return e;
     			else static if(is(E : int))
                     return ZZ(e);
     			else static if(is(E : Var))
                     return new VarExpr(e);
     			else
                     static assert(0, "no impl " ~ E.stringof);
             }

             //call sub(Expr, Expr)
             this.sub(expr(x), expr(y));

         }

        override bool opEquals(Object o) ;
     }
     ```