Template type deduction and specialization

[Daniel Kozák via Digitalmars-d-learn]

On Wed, 20 May 2015 06:31:11 +0000
Mike Parker via Digitalmars-d-learn <digitalmars-d-learn at puremagic.com>
wrote:

> I don't understand why this behaves as it does. Given the 
> following two templates:
> 
> ```
> void printVal(T)(T t) {
> 	writeln(t);
> }
> void printVal(T : T*)(T* t) {
> 	writeln(*t);
> }
> ```
> 
> I find that I actually have to explicitly instantiate the 
> template with a pointer type to get the specialization.
> 
> ```
> void main() {
> 	int x = 100;
> 	printVal(x);
> 	int* px = &x;
> 	printVal(px);        // prints the address
>          printVal!(int*)(px)  // prints 100
> }
> ```
> 
> Intuitively, I would expect the specialization to be deduced 
> without explicit instantiation. Assuming this isn't a bug (I've 
> been unable to turn up anything in Bugzilla), could someone in 
> the know explain the rationale behind this?

Because it cannot deduce type T:

try this:

void printVal(T : T*)(T* t) {
    writeln(*t);
}

void main() {
 	int x = 100;
 	int* px = &x;
 	printVal(px);
}

It will print error.

My advise is not to use T:T* or T:T[] it works only when explicitly
instantiate. Is better use T:M*,M or T:M[], M because it works
automaticly and you have both types available.

import std.stdio;

void printVal(T)(T t) {
    writeln(t);
}

void printVal(T:M*,M)(T t) {
    writeln(*t);
}

void main() {
    int x = 100;
    printVal(x);
    int* px = &x;
    printVal(px);        // prints the 100
}