"SFINAE is Evil"

[Jason House]

Ok, so you're saying you could do without SFINAE?

Christopher Wright Wrote:

> Jason House wrote:
> > I should probably expand this question...
> > 
> > Who uses templates in D? What is the most complex use you've done? Do you ever plan to get more complex? Would SFINAE make your life easier or harder?
> 
> Templates are utterly necessary and horribly untestable. I use them, but 
> I try to keep them as braindead simple as possible.
> 
> I've done a reasonable amount of work with simple templates, eg DUnit's 
> assertions, and some slightly more complex stuff, as with DMocks, but 
> nothing incredibly difficult.
> 
> DMocks was mainly a matter of looping through reflection information and 
> assembling some strings based on that, which wasn't so difficult; the 
> hardest thing (besides debugging CTFE failures and oddities with mixins, 
> but I did my best to limit the amount of both) was not being able to 
> have a variable whose type was an empty tuple. I had to wrap the tuple 
> in a templated class that would just not instantiate the arguments 
> variable with an empty tuple.
> 
> SFINAE isn't a problem for me -- I don't need to overload templates 
> much. If I did, I'd do it like this:
> 
> template Foo(T, U, V...)
> {
>     static if (condition1)
>     {
>        alias FooSpecialization1!(T, U, V) Foo;
>     }
>     else
>     // ...
> }
> 
> The only thing the compiler could do to help me that it isn't doing is 
> to make it an error to have overloaded templates.
> 
> > I've written templates classes that have one definition, and used static if as needed for specialization. I don't forsee more complex usage and view SFINAE as something that would mask bugs.
> 
> Same. The only issue is with templates from different modules or libraries.
> 
> In this case, it could be helpful for the compiler to have an error 
> message along the lines of:
> 
> template instantiation Foo!(int, float, float, char[]): could not 
> instantiate.
> Candidates are:
> valhalla.odin.Foo(T : long, U, T, V[char]) : char[] is not a V[char]
> valhalla.thor.Foo(T : class, U...) : int is not a class
> ...