• Bastiaan Veelo (57/57) Jan 24 2018 Hi,
• ag0aep6g (11/14) Jan 24 2018 Not supposed to work as it is. The spec says that you cannot make an
• Bastiaan Veelo (39/49) Jan 24 2018 Thanks a lot! I didn't know you could do overloads by way of

Bastiaan Veelo <Bastiaan Veelo.net> writes:

Hi,

`Alias this` to mixed in properties does not seem to work, see 
below. If you think it should, I'll file an issue. Otherwise: can 
this be made to work somehow?

Interestingly, if you uncomment either the mixin getter or setter 
(row 36 or 37) and its corresponding use in `main`, then the 
remaining property works. Does the compiler detect identical 
names and then does some additional mangling which messes with my 
`alias this` maybe?

```
import std.stdio;

// version = manual; // Manually written property works, 
obviously.

mixin template getter()
{
      property int p()
     {
         writeln(__LINE__, " mixin getter");
         return 3;
     }
}
mixin template setter(T)
{
      property int p(T arg)
     {
         writeln(__LINE__, " mixin setter ", typeid(T), ' ',  arg);
         return 4;
     }
}
struct S
{
     version (manual) {
          property int p()
         {
             writeln(__LINE__, " manual getter");
             return 3;
         }
          property int p(int arg)
         {
             writeln(__LINE__, " manual setter int ",  arg);
             return 4;
         }
     }
     else {
         mixin getter;            // row 36
         mixin setter!int;        // row 37
     }
     alias p this;
}


void main(string[] args)
{
     S s;
     s = 7;
     int i = s;
}
```

Error: cannot implicitly convert expression s of type S to int.

ag0aep6g <anonymous example.com> writes:

On 01/24/2018 02:24 PM, Bastiaan Veelo wrote:
 `Alias this` to mixed in properties does not seem to work, see below. If 
 you think it should, I'll file an issue. Otherwise: can this be made to 
 work somehow?

Not supposed to work as it is. The spec says that you cannot make an 
overload set just by mixing in multiple functions/methods with the same 
name. Instead, you have to do it like this:

----
mixin getter g;
mixin setter!int s;

alias p = g.p;
alias p = s.p;
----

https://dlang.org/spec/template-mixin.html#mixin_scope

Bastiaan Veelo <Bastiaan Veelo.net> writes:

On Wednesday, 24 January 2018 at 14:21:42 UTC, ag0aep6g wrote:
 The spec says that you cannot make an overload set just by 
 mixing in multiple functions/methods with the same name. 
 Instead, you have to do it like this:

 ----
 mixin getter g;
 mixin setter!int s;

 alias p = g.p;
 alias p = s.p;
 ----

 https://dlang.org/spec/template-mixin.html#mixin_scope

Thanks a lot! I didn't know you could do overloads by way of 
multiple aliases with the same name.

I meant to use this for mixing in multiple instantiations 
generated from a static foreach over an AliasSeq of types, but 
generating unique identifiers poses an extra challenge.

I may go for string mixin's instead, which I just discovered do 
work:

```
import std.stdio;

enum getter = `
      property int p()
     {
         writeln(__LINE__, " mixin getter");
         return 3;
     }
`;
string setter(string T) pure
{ return `
      property int p(` ~ T ~ ` arg)
     {
         writeln(__LINE__, " mixin setter ` ~ T ~ `" ,  arg);
         return 4;
     }
`;
}
struct S
{
     mixin(getter);
     mixin(setter("int"));
     alias p this;
}

void main(string[] args)
{
     S s;
     s = 7;
     int i = s;
}
```