D's metaprogramming could be flawed

[maik klein via Digitalmars-d]

On Friday, 22 January 2016 at 14:19:30 UTC, rsw0x wrote:
> On Friday, 22 January 2016 at 13:28:00 UTC, maik klein wrote:
>> On Friday, 22 January 2016 at 13:21:11 UTC, rsw0x wrote:
>>> On Friday, 22 January 2016 at 12:57:54 UTC, maik klein wrote:
>>>> ...
>>>
>>> You're looking for AliasSeq in std.meta, it's a tup—er, 
>>> finite ordered list of types :)
>>
>> I am already aware of AliasSeq as I have written above. But I 
>> could have misused it, would you mind showing an example with 
>> TupleRef?
>
> Sorry, I must have skipped that.
>
> Is there a reason you're explicitly using tuples?
> Unless I'm misunderstanding you, you're looking for something 
> like...
>
> struct Baz(V...) {
>   V vals;
> }
>
> which can be used like...
>
> void foo(int, int, int) {
>
> }
>
> void main(){
>   auto i = Baz!(int, int, int)();
>   foo(i.vals);
> }
>
> or am I way off base?
>
> If so, is this similar to what you're looking for?
> http://dpaste.dzfl.pl/cbae4c4ed7af
>
> Sorry if I'm nowhere near what you meant.

I think that should work but it only works because you do an 
implicit conversion with get which is quite nice.

But I was also looking for a more general solution.

I think the mixin solution could be quite nice.

static template unpack(alias f){
   pragma(inline)
   auto into(alias target, Args...)(ref Args args){
     import std.conv;
     enum s = 
`target(`~iota(Args.length).map!(i=>text(`f(args[`,i,`])`)).join(",")~`)`;
     return mixin(s);
   }
}

and use it like:

auto r = unpack!(i => i * 2).into!((a, b) => a + b)(1,2);


The only semi weird thing is that I can use this directly with my 
version of TupleRef like this:

void foo(ref int, ref int){
}

unpack!((r)=> r.get()).into!(foo)(tref.refTs.expand);


I think that is because "lambda/delegates" can not express ref 
return types?

So I think I need to do this:

ref auto get(R)(R r){
   return r.get();
}

unpack!(get).into!(foo)(tref.refTs.expand);