Variadic grouping

[JS]

On Saturday, 10 August 2013 at 17:08:57 UTC, John Colvin wrote:
> On Saturday, 10 August 2013 at 12:40:55 UTC, JS wrote:
>> On Saturday, 10 August 2013 at 10:19:34 UTC, 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
>>
>> And this is why just because something looks "unimpressive" to 
>> you doesn't mean it is... Obviously if you've never run up 
>> against the specific problems proposed by people you won't 
>> know how frustrating it is, specially when there is an easy 
>> fix. This is why those commie bastards that shoot suggestions 
>> down at first sight ruin progress... they don't have the 
>> experience with the specific issue to know just how much it 
>> sucks.
>
> That is laden with assumption.
>
> I had run in to the problem before, several times. I was not 
> initially convinced your suggestion was a good idea, especially 
> after monarch dodra posted Group. After some more experience 
> and thought I have now changed my mind.
>
> Anyway, never mind all that, what matters is the proposal.
>

Well, again, the issue is that it only becomes one once you've 
actually experienced the problem enough. This is why those that 
actually haven't even run into the problem shouldn't really have 
a say so if it is valid or not, unless they can bring some 
theoretical reason why it is flawed.

> I think this proposal is a good idea, or at least that there 
> should be some simple syntax for doing this sort of thing. In 
> particular I'd be interested in hearing from bearophile about 
> how it might fit in with his wider ideas on tuples and syntax 
> for packing/unpacking.
>
> Also, are there any corner cases that haven't been considered.
>
>   alias T = Tuple!(int, int);
>   alias Ts = Tuple!(T, T);
>
>   template A(S0..., S1...)
>   {
>       alias s0 = S0;
>       alias s1 = S1;
>   }
>
>   A!(Ts.init).s0 a;
>
> what types are a/s0 and s1?
>
> s0 == Tuple!(int, int) == s1
>
> or
>
> s0 == Tuple!(Tuple!(int, int), Tuple!(int, int))
> and s1 is an empty tuple
>
> i.e. what will the rules for auto-expansion/unpacking be?

The way I see it, using `;` is what separates groups. So in your 
above code, s1 is empty.

The `;` is shorthand for specifying groups. No where do you 
specify such a group for A!(...), so there are no groups.

There is no direct way to get your second case under my 
proposal... unless the compiler was given some additional feature 
to do so.

e.g.,

alias Ts = Tuple!(T, T);

is not the same as

alias Ts = Tuple!(T; T);

also, we would probably want to use template A(S0...; S1...) 
instead of template A(S0..., S1...)


The main thing is that `;` adds an extra symbol to split on that 
is entirely distinct from `,`. If you wanted, you could have 
Tuple! and TupleSC!. TupleSC! is used when splitting `;`. Tuple! 
and TupleSC! are not directly related(but can easily be flattened 
together if necessary.