BitArray/BitFields - Reworking with templates

[Era Scarecrow]

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