On Thursday, 19 April 2018 at 14:16:21 UTC, Alex wrote:
On Thursday, 19 April 2018 at 13:57:04 UTC, Simen Kjærås wrote:
Currently, there is no way (that I've found, at least) to do
this. If you have a workaround, that's great, but there really
should be a way - probably __traits(getOverloads). Having
__traits(getOverloads) return templates as well should fix
some of the issues __traits(getOverloads) has, as a bonus.
Would it be possible at all? I mean, if the two following codes
are equivalent
´´´
@S("Has foo_A") template foo(string s) if (s == "a") {
enum foo = "foo_A";
}
@S("Has foo_B") template foo(string s) if (s == "b") {
enum foo = "foo_B";
}
´´´
´´´
template foo(string s)
{
static if (s == "a")
{
@S("Has foo_A") enum foo = "foo_A";
}
else static if (s == "b")
{
@S("Has foo_B") enum foo = "foo_B";
}
}
´´´
How would you define a "template overload"?
And which "overloads" would you like to get if constraints are
more general?
And last but not least, the getOverloads is defined on
functions, which are callable, whereas templates are not, in
general...
Your first example defines two templates (which are overloads of
the same name), the second only one. There's no ambiguity there.
Since template instantiation is analogous to function calling
(though one is a compile-time action, the other a run-time one),
talking about template overloads in the same way as function
overloads makes perfect sense. Whether the result of
instantiating the template is a function, a value, or a type,
it's an overload of the template.
--
Simen
