Getting the overload set of a template

[Alex]

On Monday, 23 April 2018 at 14:22:13 UTC, Simen Kjærås wrote:
> As with all things D, the only real spec is the compiler source 
> code. :p :(

:p

> Proving that two templates are equivalent is in general 
> impossible, since any amount of wasted computation could be 
> performed before the end result is returned, and inputs must be 
> tested exhaustively for the proof to be valid. The fact that 
> two templates give the same result in one special case does not 
> mean that they are equivalent in the general case, and the 
> compiler needs to care about the general case.

Ok, thats exactly the point. If you have functions

void foo() {}
void foo(int n) {}

There is no ambiguity which function will be chosen if it will be 
called.

If you have templates

// form 1
template Foo(int N) if (N & 1)    {} // A
template Foo(int N) if (!(N & 1)) {} // B

OR

// form 2
template foo(int N)
{
	static if(N & 1){} // A
	else{} // B
}

There is also no ambiguity which will be called.

However, getOverloads will behave differently.

This is not bad at all. But you have to admit, that while now, 
there is no way to distinguish form 1 and form 2, with the new 
getOverloads there will be.
This seems strange to me, because there is no reason to 
distinguish form 1 and form 2. (Because the callable code, which 
will be generated is the same, I hope... ?)

So, in particular, I'm not against the feature. And if the 
equivalence between form 1 and form 2 is gone, so what. But I 
don't understand the reasoning why something which is now equal 
won't be equal any more later?