Re: Function Template Overloading

[Q. Schroll via Digitalmars-d-learn]

On Wednesday, 15 March 2017 at 02:33:36 UTC, ketmar wrote:

Q. Schroll wrote:


void test(T)(T* arg);
void test(T)(ref T arg);

Let p be any pointer. Why is test(p) not an ambiguity error? 
Why is the second overload chosen?


'cause `ref T` is more generic than `T*`. think of it as 
"greedy matching": compiler first tries to match `int*`, and if 
that failed, it tries `int`, for example. and `int*` matches 
the second template, so compiler choosing it.


Wouldn't it be better vice versa, the more specific pattern to be 
prioritized? And as it actually *can* match both, is it a 
compiler-bug not to be an ambiguity error?

Re: Function Template Overloading

[ketmar via Digitalmars-d-learn]

Q. Schroll wrote:


void test(T)(T* arg);
void test(T)(ref T arg);

Let p be any pointer. Why is test(p) not an ambiguity error? Why is the 
second overload chosen?


'cause `ref T` is more generic than `T*`. think of it as "greedy matching": 
compiler first tries to match `int*`, and if that failed, it tries `int`, 
for example. and `int*` matches the second template, so compiler choosing it.

Function Template Overloading

[Q. Schroll via Digitalmars-d-learn]

void test(T)(T* arg);
void test(T)(ref T arg);

Let p be any pointer. Why is test(p) not an ambiguity error? Why 
is the second overload chosen?
Making the first one take auto ref T* lets the compiler choose 
the first.
Making the second one non-ref lets the compiler give me an 
ambiguity error.


Template Functions are not mentioned in the spec, at least not on 
https://dlang.org/spec/function.html#function-overloading, but it 
suggests that ref should not make the decision if it can be bound 
to.