On 5/21/15 10:15 AM, Daniel Kozák via Digitalmars-d-learn wrote:
import std.stdio;
void f(T:T*)(T* t)
{
writeln("before change this is not called");
}
void f(T)(T t)
{
writeln("before change this is called");
}
void main() {
int val;
f(&val);
f!(int*)(&val);
}
now it prints:
before change this is called
before change this is not called
but if we make change as you suggest this will be print:
before change this is not called
before change this is not called
Ugh, that was not what my reading of the docs seemed to suggest:
"Function template type parameters that are to be implicitly deduced may
not have specializations"
I misread that to mean *templates* that have specializations cannot be
used for IFTI. Now I see that the rule is talking not about templates
but *template type parameters*.
But the more I look at this, the more I think this is a bad code smell.
I can't see any logical reason to do something different with an
implicit deduction vs. an explicit call. Especially in the face of other
code that Can anyone come up a valid use case for this? Even one that is
a hack?
I'll note that if you replace the specialization with:
f(T : int *)(T t)
it calls the specialized version twice. Clearly, the rule is not
properly described or not properly implemented.
I would like to hear from Walter on this, what are the thoughts behind
this rule?
-Steve
