On 7 July 2013 22:31, Dmitry Olshansky <dmitry.olsh@gmail.com> wrote:

06-Jul-2013 05:34, Manu пишет:

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) {}

The thing is that if even if you somehow force your way past IFTI what would be generated is:

f!(const int)(int arg);
f!(immutable int)(int arg);
f!(shared int)(int arg);
f!(const shared int)(int arg);

Which IMHO falls short of desired goal.
Short of using a forwarding thunk (that you don't like, but if there was force_inline?) we'd have to hack the compiler.

Hmmm, this is an interesting point.

I initially thought this was desirable, it could be useful.

But now that you point it out, I guess the point you are making is that they will all mangle separately anyway?

That seems problematic, because since all have the same return value and physical arguments, how does the compiler choose an overload to call in various circumstances?

I think I (mistakenly?) presumed they would all mangle the same, since they have the same physical signature (return value + physical args), and therefore all be the same function (eliminating the duplicates).