Template with equivalent function names

[Simen kjaeraas]

Andrej Mitrovic <andrej.mitrovich at gmail.com> wrote:

> This isn't a question but more of an observation. Here's an interesting  
> template from the docs:
>
> template Foo(T, R...)
> {
>     void Foo(T t, R r)
>     {
> 	writeln(t);
> 	static if (r.length)	// if more arguments
> 	    Foo(r);		// do the rest of the arguments
>     }
> }
>
> void main()
> {
>     Foo(1, 'a', 6.8);
> }
>
> What really intrigues me here is not the tuples which I already get, but  
> the fact that Foo is a function template. But if I remove the inner  
> Foo() function then it's not a function template anymore so the call in  
> main won't work. The inner function must have the same name as the  
> template, apparently (it doesn't even state this in the docs from what I  
> can tell!).

It is in fact mentioned, but not touted as an impressive feature:

"If a template declares exactly one member, and that member is a function
with the same name as the template, it is a function template
declaration."[1]

The same is true for struct, union, and class templates, as well as
'Implicit Template Properties', meaning any template with exactly one
member, if that member has the same name as the template itself.

In fact, shorthand eponymous templates, like struct foo(T){} or
void bar(T)(); translate internally to template foo(T){ struct foo{} }
and template bar(T){ void bar(){} }.

Other common patterns used with this trick are compile-time constants:

template foo!(int n) {
     enum foo = n;
}

and alias types:

template foo(int n, T...) {
     alias T[n] foo;
}

[1]: http://www.digitalmars.com/d/2.0/template.html#function-templates

-- 
Simen