Getting the overload set of a template

[Simen Kjærås]

On Saturday, 21 April 2018 at 21:10:29 UTC, Alex wrote:
> On Saturday, 21 April 2018 at 19:51:05 UTC, Simen Kjærås wrote:
>> On Saturday, 21 April 2018 at 11:23:33 UTC, Alex wrote:
>>> So, do you mean, that the constraint belongs to the interface 
>>> of a template?
>>
>> Not necessarily - it depends on what you want to achieve. The 
>> only thing I mean is that the code clearly defines two 
>> templates in one case (and chooses which template to 
>> instantiate based on the arguments), and one template in the 
>> other (and chooses the contents of that template based on the 
>> arguments).
>
> This is wrong, at least as I understand this:
> Lowering rules apply. These rules define a set of semantic 
> equivalent constructs. I expect all semantic equivalent 
> constructs to be handled equivalent.**

No lowering occurs here. A lowering is when the compiler takes 
one piece of syntax and replaces it with a different one, usually 
one that's more verbose.

In a way, it's kind of like a template being instantiated, in 
that you write some code and it's being replaced by something 
else. It's not, however, the same thing.

Templates are sort of like compile-time functions - overloads are 
chosen in a similar way way to how function overloads are chosen, 
and the result may depend on the parameters given. Two templates, 
just like two functions, can give the same result without the 
templates themselves being the same.


>> *In this case, there are important differences - in the first 
>> case the template itself is marked with a UDA, in the second 
>> the enum member is.
> This is a good point. But you won't be able to get the UDA from 
> an uninstantiated template will you? If you will, then, I'm 
> wrong, I think...

Why not try it?

@("Has foo1_A") template foo1(string s) if (s == "a") {
     enum foo1 = "foo1_A";
}
@("Has foo1_B") template foo1(string s) if (s == "b") {
     enum foo1 = "foo1_B";
}

template foo2(string s)
{
     static if (s == "a")
     {
            @("Has foo2_A") enum foo2 = "foo2_A";
     }
     else static if (s == "b")
     {
           @("Has foo2_B") enum foo2 = "foo2_B";
     }
}

// tuple("Has foo1_A")
pragma(msg, __traits(getAttributes, foo1));
// tuple()
pragma(msg, __traits(getAttributes, foo2));

So yes, we can. Templates are real things and can be manipulated, 
passed to other templates, etc.

--
   Simen