Static template member function for template class

Question

I have a template class and a template member function:

template<class T1>
struct A{
    template<class T2>
    static int f(){return 0;}
};

I want to specialize for a case when T1 and T2 are the same,

For example, define the case A<T>::f<T> for any T.

but I can't find the combination of keywords to achieve this.

How can I partially (?) specialize a combination of template class and a template static function?

---

These are my unsuccessful attempts, and the error messages:

1) Specialize inside the class: fatal error: cannot specialize a function 'f' within class scope)

template<class T1>
struct A{
    template<class T2>
    static int f(){return 0;}

    template<>
    static int f<T1>(){return 1;}

};

2) Specialize outside the class "simultaneously": fatal error: cannot specialize a member of an unspecialized template

template<class T>
void A<T>::f<T>(){return 1;}

3) Specialize using template<>: fatal error: too few template parameters in template redeclaration

template<> template<class T>
void A<T>::f<T>(){return 1;}

4) Invert the order: fatal error: cannot specialize (with 'template<>') a member of an unspecialized template

template<class T> template<>
void A<T>::f<T>(){return 1;}

5) Specialize the whole class (based on the error of attempt 3): fatal error: class template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list

template<class T> 
struct A<T>{
    template<>
    static int f<T>(){return 1;}
};

6) Specialize the class but not the function (?): fatal error: too few template parameters in template redeclaration template<> template<class T1>

template<> template<class T>
int A<T>::f(){return 0;}

I used clang 3.5 C++14 to generate the error messages.

Answer 1

You cannot partially specialize a function.

You can forward the work to another type:

template<class T1>
struct A;

template<class T1, class T2>
struct A_helper {
  static int f() {
    return A<T1>::f_simple<T2>();
  }
};
template<class T>
struct A_helper<T,T> {
  static int f() {
    return A<T>::f_special();
  }
};

template<class T1>
struct A{
  template<class T2>
  static int f(){return A_helper<T1,T2>::f()}
  template<class T2>
  static int f_simple(){return 0;}
  static int f_special(){return -1;}
};

or, more simply, with no A_helper:

template<class T1>
struct A{
  template<class T2>
  static int f(){return f2<T2>(std::is_same<T1,T2>{});}
  template<class T2>
  static int f2(std::true_type){
    static_assert(std::is_same<T1,T2>{}, "bob!");
    return -1;
  }
  tempalte<class T2>
  static int f2(std::false_type){return -1;}
};

you can use tag dispatching.

Another approach:

template<class T>struct tag{};

template<class T1>
struct A{
  template<class T2>
  static int f(){return f2(tag<T2>{});}
  template<class T2>
  static int f2(tag<T2>) {return 0;}
  static int f2(tag<T1>) {return -1;}
};

where we directly dispatch on the type of T2.