I’d like to do a generic function which will be specialized with some types, but I also would like to specialized with templated types, which is not allowed by the compiler.
Is there a way to get around this ?

Ideal not working implementation:

template<class D> class Dummy{public: D val;};
  
template<typename T> T foo();

template<> int foo<int>()
{
  return 0;
}

template<typename D> Dummy<D> foo<Dummy<D>>()
{
  return Dummy<D>{};
}

I get the error non-class, non-variable partial specialization ‘foo<Dummy<D> >’ is not allowed

>Solution :

Is there a way to get around this?

If a someone has a problem X, and the solution is Y, then 99% of the time specializing function templates is Z.

Make the function delegate to something that actually can be specialized any way you want:

template<typename T>
struct FooImpl {
  static void func() = delete; // Deleted default implementation
                               // Need to specialize to be valid
                               // Not strictly required, but gives
                               // more informative errors
};

template<>
struct FooImpl<int> {
  static int func() { return 1; }
};

template<typename T>
struct FooImpl<Dummy<T>> {
  static Dummy<T> func() { return {}; }
};

template<typename T>
T foo() {
  return FooImpl<T>::func();
}