Re: (non-)extern(C) function parameter vs templates

[John Colvin]

On Tuesday, 17 September 2013 at 13:36:24 UTC, Luís Marques wrote:
This works:
    extern(C) alias F = void function();
              alias G = void function();

    void foo(F f) {}
    void foo(G g) {}

Indeed, the correct foo is called, depending on whether the 
passed function is extern(C) or not (although I must say that 
the syntax for declaring the alias F is not good, IMO; the 
extern(C) should come after the equal sign).

Yet, the following does not work:

    void foo(T)(F f) {}
    void foo(G g) {}

    Error: function foo conflicts with template foo(T)(F f).

or

    void foo(F f) {}
    void foo(T)(G g) {}

    Error: template foo(T)(E e) conflicts with function foo.

It this not incoherent? If non-templated functions can overload 
on extern(C)/non-extern(C) function parameter, why can't 
templated functions?

This works for me on dmd git master:

extern(C) alias F = void function();
alias G = void function();

void foo(T)(T g) {}
void foo(F f) {}

extern(C) void a(){}
void b(){}

void main()
{
    foo(&a);
    foo(&b);
}

It used to be that templates and normal functions couldn't 
overload each other, now they can. I'm not sure when the change 
was made, it might only be in git master.