Implementing interfaces using alias this

[basile b. via Digitalmars-d-learn]

On Wednesday, 14 June 2017 at 22:29:08 UTC, Balagopal Komarath 
wrote:
> On Wednesday, 14 June 2017 at 21:04:55 UTC, basile b. wrote:
>> The way to do that in D is with mixins:
>
> That is an interesting solution.
>
> However, my original goal was to figure out whether one can 
> make struct types behave polymorphically (Which is not 
> mentioned in my original question).  I know that this is not 
> supported by design. I want to keep the original struct types 
> but also allow functions to accept those struct types and do 
> runtime dispatch. The following code should give a better idea 
> by what I mean by this.
>
> https://dpaste.dzfl.pl/051f6a4da059
>
> The user need only define Duck1, Duck2 ... with appropriate 
> functions and mixin toDuck. Then a function that accepts a Duck 
> can accept DuckLike (for dynamic dispatch) or templatize on the 
> type of Duck.

Duck typing doesn't work with the pattern you used initially.
The pattern you used initially is much more similar to the 
solution i exposed.

The point is that "alias" cant do what you wished.
It's not in the language, end of story.

Finally duck types in D are more like this:

enum looksLikeaDuck(T) = __traits(hasMember, T, "quack");

class Test(T)
if (looksLikeaDuck!T)
{
     T data;
     alias data this;
}

struct Duck
{
     void quack()
     {
         import std.stdio;
         writeln("Quack");
     }
}

void main()
{
     Test!Duck d;
}

you use traits to verify that the template parameter looks like a 
duck.
It's not like in Swift where an aggregate is used.
In D we use traits (even if traits can be used to verify that a 
template parameter is compliant with the member of an aggregate).