Essentially, I would like to write a template that calls the constructor of the parent class or the constructor of the inherited class, depending on its type.

#!/usr/bin/env dub
/+ dub.sdl:
	name "mwe"
+/
class Super {
    private int _a;
    this(){}
    this(int a) {
        _a = a;
    }

    auto opBinary(string op)(int rhs) const if (op == "+") {
        return new Super(_a + rhs); // Creates of type Super even when called from derived class
    }
}

class Derived : Super {
    this(){}
    this(int a) {
        _a = a + 1;
    }
}

void main() {
    import std : writeln;

    Super foo = new Super(1);
    Super foo2 = foo + 1; // Works fine as calls `Super` constructor

    Derived bar = new Derived(2);
    Derived bar2 = bar + 1; // Cannot implicitly cast `Super` to `Derived`
}

Some kind of return new this(...) would be good, but that's not possible.
I think it has to be done with templates, but I'm not sure how to do this.

Any help would be greatly appreciated.

On 9/20/21 6:16 PM, rjkilpatrick wrote:

...

What you want is to change that operator into a virtual function. Yes, you still have to write the overrides, but you could if you want use a mixin. Adam's solution works, but only uses the static type.

class Super {
    private int _a;
    this(){}
    this(int a) {
        _a = a;
    }

    Super performAdd(int rhs) const {
        return new Super(_a + rhs);
    }

    alias opBinary(string op : "+") = performAdd;
}

class Derived : Super {
    this(){}
    this(int a) {
        _a = a + 1;
    }

    override Derived performAdd(int rhs) {
        return new Derived(_a + rhs);
    }
}

void main() {
    import std : writeln;

    Super foo = new Super(1);
    Super foo2 = foo + 1; // Works fine as calls `Super` constructor

    Derived bar = new Derived(2);
    Derived bar2 = bar + 1; // works now

    Super b2 = bar;
    Derived d2 = cast(Derived)(b2 + 1); // ok, *and* calls Derive's version of performAdd
    assert(d2 !is null && d2._a == bar2._a);
}