• Q. Schroll (33/33) May 06 2018 Why is there a difference between

Q. Schroll <qs.il.paperinik gmail.com> writes:

Why is there a difference between

struct S
{
   template func(T)
   {
     enum impl = "whatever string";
     auto func(T arg)       { mixin(impl); } // eponymous template
     auto func(T arg) const { mixin(impl); } // eponymous template
   }
}

and

struct R
{
   private enum impl = "whatever string";
   auto func(T)(T arg)       { mixin(impl); }
   auto func(T)(T arg) const { mixin(impl); }
}

And what is the difference exactly? I know that
   auto func(T)(T arg) { mixin(impl); }
is strictly equivalent to
   template func(T) { auto func(T)(T arg) { mixin(impl); } }
so the difference is just 2 templates 1 function each vs. 1 
template 2 functions.

I don't have a simple example; here is no difference observable. 
The issue is with std.typecons.Tuple.opCmp; there are two 
templates and I tried making it one, as the implementation is 
identical. Unfortunately, one cannot use `inout` for more or less 
obcious reasons.
An attempt to put them into one template (as for struct S) does 
not work either, but I don't understand why. Solution like struct 
R works.

Is there a complete reference for how overload resolution works 
in D, including implicit template instantiation?