Template template class predicate not working in partial specialization

Question

I have many EnableIf traits that basically check whether the input type satisfies an interface. I was trying to create a generic Resolve trait that can be used to transform those into a boolean trait.

Something like this - https://wandbox.org/permlink/ydEMyErOoaOa60Jx

template <
  template <typename...> class Predicate,
  typename T,
  typename = std::void_t<>>
struct Resolve : std::false_type {};
template <template <typename...> class Predicate, typename T>
struct Resolve<Predicate, T, Predicate<T>> : std::true_type {};

Now if you have an EnableIf trait like so

template <typename T>
using EnableIfHasFoo = std::void_t<decltype(std::declval<T>().foo())>;

You can create a boolean version of that very quickly

template <typename T>
struct HasFoo : Resolve<EnableIfHasFoo, T> {};

Or the analogous variable template.

But for some reason the partial specialization is not working as expected. Resolve does not work as intended. See the output here - https://wandbox.org/permlink/ydEMyErOoaOa60Jx. The same thing implemented "manually" works - https://wandbox.org/permlink/fmcFT3kLSqyiBprm

I am resorting to manually defining the types myself. Is there a detail with partial specializations and template template arguments that I am missing?

I cannot find the reason, but you need the partial specialization to be `Resolve>`. Then at that point, you can also remove the `std::void_t` in the alias. — Guillaume Racicot, Nov 28 '18 at 06:47
btw, your code look a lot like the [dectection idiom](https://en.cppreference.com/w/cpp/experimental/is_detected) — Guillaume Racicot, Nov 28 '18 at 06:49
@GuillaumeRacicot But then what is the predicate? Just decltype()? Very nice! Also, confusing why the above approach doesn't work. — Curious, Nov 28 '18 at 06:49
It can be an alias template to simply `decltype`. I don't know why, but the `void_t` must be in the partial specialization. I think it has to do with how partial ordering work. — Guillaume Racicot, Nov 28 '18 at 06:52

Guillaume Racicot · Answer 1 · 2018-11-28T07:40:50.890

5

I cannot find the exact reason why your example don't work. If you want to dig more into the details of std::void_t, here's an interesting explanation

Even if I cannot explain it in depth, I would like to add another reliable syntax that is used in the detection idiom.

template<
    template <typename...> class Predicate,
    typename T,
    typename = void>
struct Resolve : std::false_type {};

template <template <typename...> class Predicate, typename T>
struct Resolve<Predicate, T, std::void_t<Predicate<T>>> : std::true_type {};

template <typename T>
using EnableIfHasFoo = decltype(std::declval<T>().foo());

live on compiler explorer

edited Nov 28 '18 at 07:40

answered Nov 28 '18 at 06:58

Guillaume Racicot

39,621
9
77
141

Have an upvote for the minimal change. But I deleted mine because I'm still guessing at the reasons. – StoryTeller - Unslander Monica Nov 28 '18 at 07:02
@StoryTeller Thanks. I haven't found the reason either. It might be because the rule doesn't make the specialization more specialized. – Guillaume Racicot Nov 28 '18 at 07:06
Might be. I'm examining partial ordering at the moment to see why. – StoryTeller - Unslander Monica Nov 28 '18 at 07:08
@StoryTeller I added a link to another answer that explains void_t. However, even that answer don't seem to explain your case completely. – Guillaume Racicot Nov 28 '18 at 07:12
This is an interesting take on what I was trying to do. Thanks. – Curious Nov 28 '18 at 07:14
@Curious I was sure it was about `std::void_t` being an alias to void, and mixed that with template argument deduction for the template specialization, but every experimentation showed me the contrary. Sorry I couldn't find the exact reason, but it has to do with template partial ordering or something similar. – Guillaume Racicot Nov 28 '18 at 07:40

llllllllll · Answer 2 · 2018-11-28T09:12:40.797

5

The reason why your approach will fail is that Predicate<T>> in the third template parameter is not a non-deduced context. This causes the deduction to directly fail (see [temp.alias]/2), instead of using the deduced template arguments from elsewhere as in a non-deduced context.

You can wrap your Predicate<T>> to a non-deduced context to make it work:

template<class T>
struct identity {
    using type = T;
};

template <template <typename...> class Predicate, typename T>
struct Resolve<Predicate, T, typename identity<Predicate<T>>::type> : std::true_type {};

Live Demo

Because inside a non-deduced context, the deduction won't happen for Predicate<T> part, instead, it will use the Predicate and T obtained from elsewhere.

As for why the usual detection-idiom (see Guillaume Racicot's answer) will work, it is because std::void_t as a template alias, will be replaced by void in deduction phase (see [temp.alias]/2), thus no deduction will happen.

Here are some examples to illustrate it more clearly:

template<class T>
using always_int = int;

template<template<class> class TT>
struct deductor {};

template<template<class> class TT, class T>
void foo(T, deductor<TT>) {}

template<template<class> class TT, class T>
void bar(T, deductor<TT>, TT<T>) {}

template<class T>
void baz(T, always_int<T>) {}

int main() {
    // ok, both T and TT are deduced
    foo(0, deductor<always_int>{});

    // ERROR, TT<T> is NOT a non-deduced context, deduction failure
    bar(0, deductor<always_int>{}, 0);

    // ok, T is deduced, always_int<T> is replaced by int so no deduction
    baz(0, 0);
}

edited Nov 28 '18 at 09:12

answered Nov 28 '18 at 07:42

llllllllll

16,169
4
31
54

So... why does it usually work with `void_t`? It's an alias template too. – StoryTeller - Unslander Monica Nov 28 '18 at 07:46
@StoryTeller Because the deduction starts from `std::void_t>>`, `std::void_t` is already known. – llllllllll Nov 28 '18 at 07:48
Sorry, by usually I meant `std:void_t().foo)>` – StoryTeller - Unslander Monica Nov 28 '18 at 07:49
@StoryTeller `decltype(std::declval().foo)` is a non-deduced context, compiler won't deduce from it. – llllllllll Nov 28 '18 at 07:50
1

Yeah, it is (should really print that bullet list). But shouldn't the equivalence of alias template specializations make this moot? I.e., it should be as though the OP wrote directly `std::void_t(...).foo>`, no? Sorry for flood of questions, I was just staring at these passages for too long. – StoryTeller - Unslander Monica Nov 28 '18 at 07:54
1

Oh. no wait. I see now. Great answer! That void_t we hide is failing immediately because the specialization *needs* to be replaced by its equivalent type! – StoryTeller - Unslander Monica Nov 28 '18 at 07:56

Template template class predicate not working in partial specialization

2 Answers2