Fun with templates

[Namespace]

> The way that makes the most sense to me is:
>
> void f(T)(Unqual!T t) {}
>
> Given an immutable(T) for instance that I want to call with, it 
> would
> instantiate the template with the signature void f(T), and then 
> attempt to
> call it with the immutable(T). If immutable(T) is not 
> convertible to the
> argument T, then it would produce a compile error as if 
> attempting to call
> any such function that just receives T.
>
> The point here is that I want more control over the signature 
> of the
> instantiated template (reduce the number of permutations 
> generated for
> various calls). Template blow-out is perhaps the biggest and 
> most well
> known day-to-day problem in C++, and tools like this may be 
> very valuable
> to mitigate the disaster.

It seems that your code works if you put the Template Type 
explicit:
----
import std.stdio;
import std.traits : Unqual;

void foo(T)(Unqual!T a) {
	writeln(typeof(a).stringof, " <-> ", T.stringof);
}

void main() {
	int a;
	const int b;
	immutable int c;

	//foo(c); /// Error
	foo!(typeof(a))(a);
	foo!(typeof(b))(b);
	foo!(typeof(c))(c);
}
----