Here's a weird little program that came up in a recent Discord discussion:

template fun(T)
{
    string fun(T) => fun("hi");
    string fun(string) => "inner";
}
string fun(string) => "outer";

void main()
{
    import std.stdio;
    writeln(fun(123));
}

What SHOULD this program do?

1. Print "inner".
2. Print "outer".
3. It shouldn't compile.

What do you think it ACTUALLY does?

1. Print "inner".
2. Print "outer".
3. It doesn't compile.

On Wednesday, 19 March 2025 at 03:40:28 UTC, Paul Backus wrote:

template fun(T)
{
    string fun(T) => fun("hi");
    string fun(string) => "inner";
}
string fun(string) => "outer";

void main()
{
    import std.stdio;
    writeln(fun(123));
}

It should print outer and does print outer
you didnt actually introduce ambiguity

template fun(alias T)
{
    string fun(T) => fun("hi");
    string fun(string) => "inner";
}
string fun(string) => "outer";

void main()
{
    import std.stdio;
    writeln(fun(123));
}

fails

On Wednesday, 19 March 2025 at 03:40:28 UTC, Paul Backus wrote:

It should print “outer”, and it actually does.

Obviously, at first I expected it to print: “inner”. But when I saw the result and checked the spec, I think that it works correctly.

There are three non-obvious things ging in here.

Number one: fun(T).fun(string) is not a regular function, it’s a template. So it doesn’t collide with globally-defined fun(string). This is why this program compiles.

Number two: inside eponymous template fun, fun refers to the template itself, not to its members. This gives a different result:

template fun(T) {
    alias fun = f;
    string f(int) => f("hi");
    string f(string) => "inner";
}
string f(string) => "outer";

void main() {
    import std.stdio;
    writeln(fun!int(123)); // sorry, IFTI no longer works
}

Number three: using a type instead of template parameter (of the same type) is enough to break implicit instantiation:

template fun(T) {
    string fun(string) => "inner";
}

void main() {
    import std.stdio;
    writeln(fun("hi")); // error
    writeln(fun!string("hi")); // works
}

There are many other ways to break IFTI:

template fun(T) {
    alias fun = fun;
    string f(T) => "inner";
}

template fun(T) {
    template fun(T) {
        string fun(T) => "inner";
    }
}

I guess it can’t be helped. Usually, though, IFTI failure results in error. In this program, it leads to unforeseen behavior. But such is life on templates.

On Wednesday, 19 March 2025 at 03:40:28 UTC, Paul Backus wrote:

template fun(T)
{
    string fun(T) => fun("hi");
    string fun(string) => "inner";
}
string fun(string) => "outer";

void main()
{
    import std.stdio;
    writeln(fun(123));
}

Print "inner". Local symbol should hide the module-scope symbol, and "inner" printer is local from where fun("hi") is called. The spec says that function overloading rules should only apply to functions in the same scope.

No idea. What I think it ought to do would be my expectation but the fact you posted this as a riddle hints it maybe doesn't work like that.

On Wednesday, 19 March 2025 at 10:31:36 UTC, Ogion wrote:

Well duh, I see how this causes the program to print "outer", but is this actually how it should be? If, why?

On Wednesday, 19 March 2025 at 10:31:36 UTC, Ogion wrote:

Sometimes...but not all the time. Check this out:

template fun(T)
{
    // call via function pointer
    string fun(T) => (&fun)("hi");
    string fun(string) => "inner";
}
string fun(string) => "outer";

void main()
{
    import std.stdio;
    writeln(fun(123));
}

On Wednesday, 19 March 2025 at 10:31:36 UTC, Ogion wrote:

That's what I don't like. I'd prefer it to refer to the members of the template instance unless qualified.

On Wednesday, 19 March 2025 at 03:40:28 UTC, Paul Backus wrote:

template fun(T)
{
    string fun(T) => fun("hi");
    string fun(string) => "inner";
}
string fun(string) => "outer";

void main()
{
    import std.stdio;
    writeln(fun(123));
}

What an overload-set nightmare.

3 because two candidates of the set match.

I play the game, I haven't compiled the thing but I'd say "hi".