On Tuesday, 31 July 2012 at 05:27:58 UTC, Philippe Sigaud wrote:
No. Use a 3-params template or a tuple:
void func(A,B,C)(X!(A,B,C) x) {}
or
void func(Ts...)(X!(Ts) x) {}
I don't know how many arguments it will have (depends on how
many options I give it), and I honestly don't; It should be
invisible for the end user as long as we can get the the
constraints properly accepted.
or even, more general:
void func(T)(T x) if (is(T t = X!(SomeTypes), SomeTypes...)),
because template constrains are much more powerful and general
than fiddling arguments types.
That doesn't make sense; but I don't have a full grasp of the
templates (continued below).
There was a discussion between Simen Kjaeraas and me on the
subject not long ago. Kenji Hara extended the functionnality of
is( , T...) and did a pull request. I'm not sure it's in 2.060,
the request was done a week ago.
so the (, T...) is shorthand for testing the template type with
multiple arguments. Nice. So multiple arguments would be...
struct X (T, U) {}
if(is(T t = X!(bool, bool), (int, int), (int, bool))) //?
I want to say no... But I haven't actually tested it for my
use cases. Leaving it unconstrained (without checking) to make
it work is a disaster waiting to happen: I want T and U to
both be of the same template (X in this case) but not the same
instantiation arguments.
Said like this, it's much more clear for me :)
Note that in the above code, SomeType is a fresh variable in
each is() expression. So, even though I used the same name
(shouldn't have done that), T and U can have different type
parameters.
*shameless plug*
Btw, I wrote a tutorial on templates, you can find it here:
https://github.com/PhilippeSigaud/D-templates-tutorial/blob/master/dtemplates.pdf
(click on 'view raw', that should download the pdf)
That should shed some light on the matters at hand.
Indeed... I remember glancing through it, but never really
needed it badly; Now it seems I do. At least it's not C++ and
it's templates. I'll be reading up on them starting tonight (and
printing most of it); It is after all the hardest part (and most
powerful part) of the language :P
