Fun with templates

[monarch_dodra]

On Saturday, 6 July 2013 at 01:35:09 UTC, Manu wrote:
> Okay, so I feel like this should be possible, but I can't make 
> it work...
> I want to use template deduction to deduce the argument type, 
> but I want
> the function arg to be Unqual!T of the deduced type, rather 
> than the
> verbatim type of the argument given.
>
> I've tried: void f(T : Unqual!U, U)(T a) {}
> and: void f(T)(Unqual!T a) {}
>
> Ie, if called with:
>   const int x;
>   f(x);
> Then f() should be generated void f(int) rather than void 
> f(const int).
>
> I don't want a million permutations of the template function 
> for each
> combination of const/immutabe/shared/etc, which especially 
> blows out when
> the function has 2 or more args.
>
> Note: T may only be a primitive type. Obviously const(int*) can 
> never be
> passed to int*.

You could just forward to an implementation template, passing 
explicitly the arguments. This is kind of like the "take" 
function making an explicit call to "Take!T" I guess. In any 
case, this is what I mean.

--------
void foo(T)(T t)
{
     fooImpl!(Unqual!T)(t);
}
void fooImpl(T)(T t)
{
     static assert(is(Unqual!T == T));
     //do it
}

void main()
{
     const(int) x;
     foo(x);
}
--------

This should do what you want. foo should be completly inlined 
away I believe. It is a tiny bit hackish, but should work. You'll 
generate all flavors of foo, but only Unqual'd versions of 
fooImpl (which is what you care about). You can also add some 
"isPrimitivee!T" if you want or something.

Not sure how this deals with "shared" ? In any case, you asked 
for "Unqual", so that's what you get ;)