DIP66 - Multiple alias this

[IgorStepanov via Digitalmars-d]

On Friday, 10 October 2014 at 21:26:49 UTC, Steven Schveighoffer 
wrote:
> On 10/10/14 5:15 PM, IgorStepanov wrote:
>> On Friday, 10 October 2014 at 20:47:45 UTC, Steven 
>> Schveighoffer wrote:
>>> On 10/10/14 1:09 PM, IgorStepanov wrote:
>>>> I've created DIP for my pull request.
>>>> DIP: http://wiki.dlang.org/DIP66
>>>> PR: https://github.com/D-Programming-Language/dmd/pull/3998
>>>>
>>>> Please, comment it.
>>>
>>> This part:
>>>
>>> void test()
>>>    {
>>>        C c;
>>>        int i = c; //Error: c.a.i vs c.b.i
>>>    }
>>>
>>>    static assert(is(C : int)); //Ok, because C is subtype of 
>>> int anyway.
>>>
>>> I think might be wrong. There is a lot of code out there that 
>>> says, e.g.:
>>>
>>> void foo(T)(T t) if(is(T : U))
>>> {
>>>  U u = t;
>>>  ...
>>> }
>>>
>>> Which will now create an error in the wrong place. IMO, the 
>>> 'is' test
>>> should also fail.
>>>
>>> -Steve
>>
>> I thought exactly about this using case.
>>
>> See:
>> You have a struct like this in first place:
>>     struct A
>>     {
>>         int i;
>>         alias i this;
>>     }
>>
>>     struct C
>>     {
>>         A a;
>>         string s;
>>         alias a this;
>>         alias s this;
>>     }
>>
>> And you have a template function in second place:
>> void foo(T)(T t) if(is(T : int))
>> {
>> ...
>> }
>>
>> void foo(T)(T t) if(is(T : string))
>> {
>> ...
>> }
>>
>>
>> And you have the code it third place:
>> C c;
>> foo(c); //Error: what do you mean: foo!(T : string) or foo!(T 
>> : int)
>
> I agree with all this.
>
>> Now, someone (A developer) changed the A definition:
>>
>>     struct A
>>     {
>>         int i;
>>         alias i this;
>>     }
>>
>>     struct B
>>     {
>>         int i;
>>         alias i this;
>>     }
>>
>>     struct C
>>     {
>>         A a;
>>         B b;
>>         string s;
>>         alias a this;
>>         alias b this;
>>         alias s this;
>>     }
>>
>> And now, you code mystically start to works.
>
> Why? It's just as confused as before, no?
>
> The way the DIP reads, the call to foo(c) compiles, but the 
> instantiation fails. This can cause subtle issues when you want 
> to select an instantiation based on what it casts to.
>
> An example:
>
> foo(T)(T t) if(is(T : int))
> {
>    someFuncThatTakesInt(t);
> }
>
> foo(T)(T t) if(!is(T : int) && is(T.shadow : int))
> {
>    someFuncThatTakesInt(t.shadow);
> }
>
> struct A
> {
>    int i;
>    alias i this;
> }
>
> struct B
> {
>    int i;
>    alias i this;
> }
>
> struct C
> {
>    A a;
>    B shadow;
>    alias a this;
>    alias shadow this;
> }
>
> C c;
> foo(c); // should compile, but I think your DIP makes it fail 
> due to ambiguity
>
> -Steve

You can write foo(c.shadow); This isn't hard.
Ok, I understood you, let's listen to what others say