Restriction on interface function types

[Frustrated]

On Wednesday, 12 March 2014 at 10:57:10 UTC, Steve Teale wrote:
> interface I
> {
>    auto myType();
> }
>
> class A: I
> {
>    auto myType() { return cast(A) null; }
> }
>
> void main()
> {
>    I x = getSomeI();
>    typeof(x.myType()) y;
> }

Check out: 
http://forum.dlang.org/thread/ljqbcbitfptxqjauppte@forum.dlang.org
/ http://dpaste.dzfl.pl/6c90ca418996

It does what you want. As mentioned, you can't quite do this at 
compile time because the types must be known(or else just use 
object or a void *).

You can, though do this at runtime:

interface I
{
    I myType(); // can return anything that derives from I

}

class A : I
{
     final A _myType() { return cast(A) null; }

     //mixin(AbstractToInterface!(A, I, A)); // (won't work as is 
because only return type of myType will be different. Need to use 
different names)

     // The mixin would create the following function if slightly 
modified
     I myType() { return _myType; }
}

void main()
{
    I x = getSomeI();
    typeof(x._myType()) y1;
    typeof(x.myType()) y2;
    typeof(cast(Object)x.myType()) y;
}

y1 = y2 = I, y = A. (cast(Object) has to do with the weird way D 
handles interface types)

Note, that this code works in that if a new class B is created, 
it can return it's type:


class B : I
{
     final B _myType() { return cast(B) null; }
     I myType() { return _myType; }
}



If getSomeI() returns B then y = B.


Of course it's way easier just to do
typeof(cast(Object)x) y; unless you want to potentially return 
different objects.