Variadic grouping

[JS]

On Saturday, 10 August 2013 at 18:28:39 UTC, Artur Skawina wrote:
> On 08/10/13 12:19, John Colvin wrote:
>> On Monday, 29 July 2013 at 13:23:23 UTC, JS wrote:
>>> Sometimes it's nice to be able to have groups of variadic 
>>> parameters:
>>>
>>> template t(T1..., T2...)
>>>
>>> ...
>>>
>>> t!(a, b, c; d, e, f);
>>>
>>> so that a,b,c are for T1 and d,e,f are for T2.
>>>
>>> This can be done by making a symbol and breaking up a single 
>>> variadic but is messy.
>>>
>>> I doubt such a feature will ever get added but who knows...
>> 
>> I was initially unimpressed, but after some recent work I 
>> would really like this feature. I have been using
>>   struct Group(T...)
>>   {
>>       alias Ungroup = T;
>>   }
>> but, useful as it is, this feels like something that should 
>> have some sugar on it.
>> 
>>   template A(T0 ..., T1 ...)
>>   {
>>   // use T0 & T1
>>   }
>> 
>>   A!(int, long, double; Point, int)
>> 
>> is so much nicer than
>> 
>>   template A(T0, T1)
>>   if(isGroup!T0 && isGroup!T1)
>>   {
>>       alias t0 = T0.Ungroup;
>>       alias t1 = T1.Ungroup;
>> 
>>       //use t0 && t1
>>   }
>> 
>>   A!(Group!(int, long, double), Group!(Point, int))
>
>    template Tuple(A...) { alias Tuple = A; }
>
>    template Ungroup(G...) if (G.length==1) {
>       static if(__traits(compiles, Tuple!(G[0].Ungroup)))
>          alias Ungroup = Tuple!(G[0].Ungroup);
>       else
>          alias Ungroup = Tuple!(G[0]);
>    }
>
> then
>
>    template A(T...) {
>       //alias t0 = Ungroup!(T[0]);
>       //alias t1 = Ungroup!(T[1]);
> 
>       //use t0 && t1
>
>       static assert( {
>          foreach (ET; T)
>             pragma(msg, Ungroup!ET);
>          return 1;
>       }());
> 
>       alias A = Ungroup!(T[0])[0];
>       Ungroup!(T[2])[$-1] AFloat;
>    }
>
>    A!(Group!(int, long, double), Group!(Point, int), float) x;
>    A!(int, Group!(Point, int), Group!("f", float)) x2;
>    A!(int, Group!(Point, int), float, "blah", double, 
> Group!(ubyte, "m", float[8], 3.14)) x3;
>    A!(int, 0, float, Group!(ubyte, "m", float[2], 
> Group!(Group!(int,11,12), Group!(float,21,22)))) x4;
>
>
> Using just ';' would: a) be too subtle and confusing; b) not be 
> enough
> to handle the 'x4' case above.
>
> artur

a) thats your opinion.

b) wrong. Using Group is just an monstrous abuse of syntax. It's 
not needed. I don't think there is a great need for nested 
groupings, but if so it is easy to make ';' work.

Do your really think

that Group!() is any different than `;` as far as logic goes? If 
so then you really need to learn to think abstractly.

This is like saying that there is a difference between using () 
or {} as groupings. There is no semantic difference except what 
you choose to put on it. Hell we could use ab for grouping 
symbols.

Group!() and (); are the same except one is shorter and IMO more 
convienent... there is otherwise, no other difference.

to see this, x4 can be written as


A!(int, 0, float, (ubyte, "m", float[2], ((int,11,12), 
(float,21,22)))) x4;

Note, all I did was delete Group!. IT IS HAS THE EXACT SAME 
LOGICAL INTERPRETATION. Just because it is more confusing for you 
does mean anything except you need to try harder.

In this case, there is no need to use `;` because there is no 
group separation(in your definition of A). I would prefer to 
write it as

A!(int, 0, float, (ubyte, "m", float[2], (int,11,12; 
float,21,22))) x4;

As I can see the groups easier. In this case the ; serves only to 
distinguish linear groupings, not nested ones as it can't do 
this... brackets must be used.


Linear groupings(sequential groups) are what is going to be used 
most of the time. I did not not have the need for nesting groups 
so didn't use brackets but it would be something needed for some. 
I don't think there would be a huge reason to have nested 
groupings since it is generally a compile time construct but I 
suppose in some instances it could be useful. e.g., key value 
pairs: ((k1, v1), (k2, v2), ...) but even then one could just 
write it (k1, v1; k2, v2; ....)

The main point is that what you are trying to offer does not 
simplify things... and simplification is what is important. D can 
already do what is required in a roundabout way but it requires 
extra work and is more verbose(which I think, in general, is bad).

I'd rather have something like # instead of group. e.g.,


Just because you add some symbol in front of brackets does not 
magically make anything you do different... just extra typing.


>    A!(int, 0, float, #(ubyte, "m", float[2], #(#(int,11,12), 
> #(float,21,22)))) x4;


But there should be no need for # as there is no need for Group. 
(again, I'm not talking about what D can do but what D should do)