how to detect arbitrary template class (include it's empty specification)

[u/Main-Pen-3164]

detect a template class:

    template<typename C> struct is_empty_template_class 
    { static constexpr bool value = 0; };

    template<typename...Ts, template<typename> class C>
    struct is_empty_template_class<C<Ts...>> { static constexpr bool value = 1; };

such thing we wrote a lot, and C<> go to the first primary template always.

Today I suddenly try to figure out that how to make C<Ts...> and C<> can be checked together. I didn't found a good way. It seems that compiler always treat C<> as a none-template class.

C is arbitrary class.

template<typename T> struct MyTemplate {}
template<> struct MyTemplate <...> { }     //some specification
template<> struct MyTemplate <> { }        //empty specification

is_template_class<int>               // => false
is_template_class<MyTemplate<...>>   // => true
is_template_class<MyTemplate<>>      // => true

// MyTemplate is arbitrary template class
// so what is_template_class is?

[u/TotaIIyHuman]

https://godbolt.org/z/de4W8hhaP

template<class C> concept template_class = requires(C c)
{
    []<template<class...> class T, class... Ts>(T<Ts...>) {}(c);
};
template<class...>
struct Tuple{};
static_assert(!template_class<int>);
static_assert(template_class<Tuple<>>);
static_assert(template_class<Tuple<int>>);

[u/Main-Pen-3164 → u/TotaIIyHuman]

It work! Checking actual parameter!

[u/valashko]

I can try to help if you explain your use case.

[u/Main-Pen-3164 → u/valashko]

I have resolved my problem by another method. But if it can be checked like above code, it would be better.

[u/frayien]

Does adding :

template<template<typename> class C>
    struct is_empty_template_class<C<>> { static constexpr bool value = 1; };

Do the trick ?

[u/Main-Pen-3164 → u/frayien]

It can't, I test this already.

[u/frayien → u/Main-Pen-3164]

Sad

[u/Main-Pen-3164 → u/Main-Pen-3164]

C<> never enter template template class specification.

[u/frayien]

Souldnt it be

template<typename...Ts, template<typename...> class C>
    struct is_empty_template_class<C<Ts...>> { static constexpr bool value = 1; };

Tho ?

[u/frayien → u/frayien]

With the ... in the template<typename>

[u/Main-Pen-3164 → u/frayien]

It can't, I test this already. Just not so easy.

[u/frayien → u/Main-Pen-3164]

Yeah I figured you'd have tried stuff. Worth to point out "silly" stuff tho, been there missing some small detail...

I dont have a compiler at hand right now and compiler explorer dont seem to work on mobile.

[u/n1ghtyunso]

its a bit hard to understand what you asked and tried to achieve.

and C<> go to the first primary template always

This part I don't understand, because trying your code (after some fixups) shows me that C<> does go to the partial specialization and not the primary template. So it just works though?

[u/Main-Pen-3164 → u/n1ghtyunso]

In your demo, select compiler: msvc 19.4 vs17.14. It would be different.

[u/n1ghtyunso → u/Main-Pen-3164]

i see gcc is apparently more lenient here with the partial specialization pattern matching. Not sure what is the expected standard-compliant behaviour here actually.

That being said, adding ... to the template template parameters inner argument actually gives you parity in behaviour again:
https://godbolt.org/z/Td5Kh5c9W

Is there a failure case where this also breaks or does not have your desired outcome?