SFINAE working in return type but not as template parameter

Question

I already used the SFINAE idiom quite a few times and I got used to put my std::enable_if<> in template parameters rather than in return types. However, I came across some trivial case where it didn't work, and I'm not sure why. First of all, here is my main:

int main() {     foo(5);     foo(3.4); } 

Here is an implementation of foo that triggers the error:

template<typename T,          typename = typename std::enable_if<std::is_integral<T>::value>::type> auto foo(T)     -> void {     std::cout << "I'm an integer!\n"; }  template<typename T,          typename = typename std::enable_if<std::is_floating_point<T>::value>::type> auto foo(T)     -> void {     std::cout << "I'm a floating point number!\n"; } 

And here is a supposedly equivalent piece of code that works fine:

template<typename T> auto foo(T)     -> typename std::enable_if<std::is_integral<T>::value>::type {     std::cout << "I'm an integrer!\n"; }  template<typename T> auto foo(T)     -> typename std::enable_if<std::is_floating_point<T>::value>::type {     std::cout << "I'm a floating point number!\n"; } 

My question is: why does the first implementation of foo triggers that error while the second one does not trigger it?

main.cpp:14:6: error: redefinition of 'template<class T, class> void foo(T)'  auto foo(T)       ^ main.cpp:6:6: note: 'template<class T, class> void foo(T)' previously declared here  auto foo(T)       ^ main.cpp: In function 'int main()': main.cpp:23:12: error: no matching function for call to 'foo(double)'      foo(3.4);             ^ main.cpp:6:6: note: candidate: template<class T, class> void foo(T)  auto foo(T)       ^ main.cpp:6:6: note:   template argument deduction/substitution failed: main.cpp:5:10: error: no type named 'type' in 'struct std::enable_if<false, void>'           typename = typename std::enable_if<std::is_integral<T>::value>::type>           ^ 

EDIT :

Working code and faulty code.

Answer 1

You should take a look at 14.5.6.1 Function template overloading (C++11 standard) where function templates equivalency is defined. In short, default template arguments are not considered, so in the 1st case you have the same function template defined twice. In the 2nd case you have expression referring template parameters used in the return type (again see 14.5.6.1/4). Since this expression is part of signature you get two different function template declarations and thus SFINAE get a chance to work.