Eponymous template with full template syntax

[monarch_dodra]

On Monday, 1 July 2013 at 20:28:28 UTC, Ali Çehreli wrote:
> On 07/01/2013 12:03 PM, Maxim Fomin wrote:
>
> > I think that this probably worked as early as in the end of
> 2011 but I
> > can be wrong as don't remember exactly.
>
> To answer Jonathan's question as well, it must have worked 
> because I see it in code that is definitely tested when it was 
> written.
>
> > It seems that dmd recognizes isSmall!int.isSmall as potential
> UFCS
> > property, converts isSmall!int to bool and tries to issue call
> > isSmall(bool) and fails, because that template does not
> define any
> > function.
>
> That explains it. :) Let's play with it a little:
>
> import std.stdio;
>
> template isSmall(T)
> {
>     enum isSmall = (T.sizeof < 12345);
>
>     struct S
>     {
>         T m;
>     }
> }
>
> struct S
> {
>     int[10] i;
> }
>
> void main()
> {
>     writeln(isSmall!int);
>     writeln(isSmall!int.S.init);
>     writeln(isSmall!int.S);
> }
>
> First of all, apparently a template can include a definition 
> with the same name but I still cannot type isSmall!int.isSmall. 
> I guess the above is still an eponymous template and 
> isSmall!int still means isSmall!int.isSmall.
>
> Now guess what the last two lines print. :) isSmall!int.S is 
> *not* the S that is included in the template! Here is the 
> output:
>
> true
> S([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
> S([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
>
> The last line is actually an anonymous struct object of type S 
> (the S that is defined at module level).

I though UFCS wasn't possible with constructors? *That* very 
usecase is one of the reasons why. Shouldn't that be an 
accepts-invalid?

> That is confusing.

UFCS construction: Yes. The rest, not so much:

The idea is that once a template is "eponymous", it *fully* 
becomes the eponymous function/type/value (s). Every other 
function, regardless of public/private*, simply seizes to exist 
to the outside world. You can't make a "qualified" call to an 
eponymous template, because the "qualification" is already the 
call. Long story short, it's not mix and match: Either you have a 
normal template, or you have an something eponymous, not a bit of 
both:

*What qualifies for eponymous template is kind of "buggy", since 
what actually qualifies is not exactly what the spec says. Still, 
*once* something is considered "qualified" by the implementation, 
then it is fully eponymous.