Template specialization with enable_if fails in Clang, works with GCC - c++

Question

I am trying to remove a member function based on the template type. The problem is to make a later template specialization match the type signature of my function in a case when it is not removed.
I tried the following code, which compiles with GCC (9.0.1) but gives an error in Clang (9.0.0). I think it also fails to build the code in MSVC++.
#include <type_traits>
#include <iostream>
template <typename T>
struct my_type {
template <typename Q = T>
std::enable_if_t<!std::is_same<bool, Q>::value, my_type<T>> my_fun(const my_type<T>& v) {
std::cout << "Base";
return v;
}
};
template <>
template <typename Q>
std::enable_if_t<!std::is_same<bool, double>::value, my_type<double>> my_type<double>::my_fun(const my_type<double>& v) {
std::cout << "Specialized";
return v;
}
int main()
{
my_type<double> aa, bb;
aa.my_fun(bb);
}
The error with Clang is
prog.cc:16:88: error: out-of-line definition of 'my_fun' does not match any declaration in 'my_type<double>'
std::enable_if_t<!std::is_same<bool, double>::value, my_type<double>> my_type<double>::my_fun(const my_type<double>& v) {
^~~~~~
1 error generated.
I would like to know how to make the code work, and also why the results are not consistent cross all the major compilers.

Answer 1

In both cases: my_type is specialised to double. Then compare non-specialised version of my_fun
template < >
template <typename Q>
std::enable_if_t<!std::is_same_v<bool, Q>::value, my_type<double>>
// ^ (!)
my_type<double>::my_fun(const my_type<double>& v)
against the fully specialised my_fun:
template < >
template < >
// ^
std::enable_if_t<!std::is_same<bool, double>::value, my_type<double>>
my_type<double>::my_fun<double>(const my_type<double>& v)
// ^
Both of above variants would be legal; you, in contrast, ended up somewhere in between...
GCC accepting this code doesn't look right to me, I join the 'this is a bug' fraction in the comments.
Perhaps even worse: Consider my_type<double>::my_fun<bool> specialisation – it should still exist, shouldn't it?

Answer 2

I don't know how to make this work with specialization. But I do know how to just side-step the issue entirely:
template <typename> struct tag { };
template <typename Q = T>
std::enable_if_t<!std::is_same_v<bool, Q>, my_type<T>> my_fun(const my_type<T>& v) {
return my_fun_impl(v, tag<Q>{});
}
with:
template <typename U>
my_type my_fun_impl(const my_type& v, tag<U>) {
std::cout << "Base";
return v;
}
my_type my_fun_impl(const my_type& v, tag<double>) {
std::cout << "Specialized";
return v;
}
If you wanted specialization to give users the ability to add specialized implementations, you could make my_fun_impl a free function instead of a member function. If the goal was just to specialize for certain types, you can make them private member functions.

Answer 3

You cannot use enable_if here to suppress a member function depending on the template parameter of the class, i.e. T (but only depending on the template parameter of the function, i.e. Q.
Your code is wrong, as clang rightly points out. I don't know why gcc accepts it and how it can detect what Q is in your 'specialisation' (I reckon your code compiled with gcc stated "Base" -- correct? Also as there is no inheritance, it's not clear why you use "Base".)
W/o tag type, you could do the following.
template <typename T>
struct my_type {
private:
template<bool Standard>
std::enable_if_t<Base, my_type> my_fun_impl(const my_type& v)
{
std::cout << "Standard";
return v;
}
template<bool Standard>
std::enable_if_t<!Standard, my_type> my_fun_impl(const my_type& v)
{
std::cout << "Specialised";
return v;
}
public:
my_type my_fun(const my_type& v)
{
return my_fun_impl<is_standard<T>::value>(v);
}
};
for whatever is_standard<> you want.