#include <iostream>

template<class T>
class TTest;

template<class R, class T>
class TTest<R(T)>
{
public:
  TTest(){};
  R square(T _t) { return (R)_t * _t; }
};

// Void
template<class T>
void test(T);

// class R
template<class R, class T>
R test(TTest<R(T)> _test)
{
  return _test.square(2);
}

int main()
{
  TTest<float(int)> obj;
  float a = test(obj);
  std::cout << "A: " << a;
}

1.3.10 signature
the information about a function that participates in overload resolution (13.3): the types of its parameters
and, if the function is a class member, the cv- qualifiers (if any) on the function itself and the class in which
the member function is declared.2) The signature of a function template specialization includes the types of
its template arguments (14.5.5.1).

14.5.5.1/4
The signature of a function template consists of its function signature, its return type and its template parameter list.
...

template<class T>
void test(T);

N>// Void
N>template<class T>
N>void test(T);

N>// class R
N>template<class R, class T>
N>R test(TTest<R(T)> _test)
N>{
N>  return _test.square(2);
N>}
N>

void test(int);
void test(float);
void test(long);

float test(TTest<float(int)> _test);
long test(TTest<long(float)> _test);
int test(TTest<int(long)> _test);