Is there any way of detecting arbitrary template classes that mix types and non-types?

Question

Is there any way of detecting whether a class is a normal type or is an instantiation of a template type (meta type) which may include non-type parameters? I came up with this solution:

#include <iostream>

template <template<class...> class> 
constexpr bool is_template()
{
    return true;
}

template <class> 
constexpr bool is_template()
{
    return false;
}

struct Foo{};

template<class> struct TemplateFoo{};

template<class, int> struct MixedFoo{};

int main()
{
     std::cout << std::boolalpha;
     std::cout << is_template<Foo>() << std::endl;  
     std::cout << is_template<TemplateFoo>() << std::endl;  
     // std::cout << is_template<MixedFoo>() << std::endl; // fails here
}

however it will fail for templates that mix non-types and types, like

template<class, int> struct MixedFoo{};

I am not able to come up with any solution, except the one in which I must explicitly specify the types in the overloads. Of course this is un-reasonable due to combinatorial explosion.

Related question (not a dupe): Is it possible to check for existence of member templates just by an identifier?

Answer 1

No, there is not.

Note that template classes are not classes themselves. They are templates for classes.

Answer 2

I guess it is not possible.

Anyway, you can use the other way around and let N be deduced:

template<class, class> struct MixedFoo;
template<class C, int N> struct MixedFoo<C, std::integral_constant<int, N>>{};

Now, this returns true as expected:

 std::cout << is_template<MixedFoo>() << std::endl; // fails here

Of course, you won't be able anymore to use MixedFoo as MixedFoo<int, 2>, so I'm not sure it's worth it.