Цикл понятий C++

Концепции изначально слишком слабы для выполнения метапрограммирования, поэтому для этого вам потребуется некоторая «метапрограммирующая помощь» от остальной части языка. Я бы использовал специализацию шаблона, чтобы разложить тип на шаблон и его параметры типа, а затем потребовал, чтобы все эти параметры удовлетворяли C_Type:

template <class>
constexpr bool TypeTuple_ = false;
template <template <class...> class Tuple, class... Types>
  requires (C_Type<Types> && ...)
constexpr bool TypeTuple_<Tuple<Types...>> = true;

template <class T>
concept bool TypeTuple = TypeTuple_<T>;

Это работает с hana::tuple и std::tuple — любым шаблоном, который принимает все параметры типа.

Я не очень хорошо разбираюсь в концепциях, но вы, безусловно, можете добиться этого с помощью Boost.Hana несколькими способами.

Глядя на комментарии, следует отметить, что любой тип кортежа может быть преобразован в hana::Sequence, который по соглашению также является hana::Searchable и hana::Foldable.

Вот пример с std::tuple, используемым как hana::Searchable:

#include <boost/hana.hpp>
#include <boost/hana/ext/std/tuple.hpp>
#include <tuple>
namespace hana = boost::hana;

template < typename T >
concept bool  C_Type = requires {
  typename T::type;
};

auto is_C_Type = hana::overload_linearly([](C_Type const&) { return hana::true_c; },
                                         [](auto const&)   { return hana::false_c; });

template < typename T >
constexpr bool foo(T const& tuple) {
  return hana::all_of(tuple, is_C_Type);
}

int main() {
  constexpr auto  test = std::tuple{hana::type_c<int>, hana::type_c<double>};
  static_assert(foo(test));
}

https://wandbox.org/permlink/YNZDX7uN6mgUdmje

Вот пример того, как вы можете проверить, содержит ли tuple только типы, определяющие имя типа type. Хитрость заключается в том, чтобы определить тип кортежа, который определяет новый тип std::pair<std::pair<...std::pair<void, T0>, ...TN>, TM> для кортежа std::tuple<T0, ..., TN, TM>. Этот работает в GCC 7.2. Мне было бы интересно, как еще один четко сочетает вариативные ограничения, поскольку я не нашел никаких ссылок.

#include <array>
#include <tuple>

template<typename T>
struct Type {
    using type = T;
};

template<typename Tuple, size_t I = std::tuple_size<Tuple>::value>
struct TupleType {
    using type = std::pair<typename TupleType<Tuple, I - 1>::type,
                           typename std::tuple_element<I - 1, Tuple>::type>;
};

template<typename Tuple>
struct TupleType<Tuple, 0> {
    using type = void;
};

template<typename T>
concept bool C_TupleType = requires {
    typename TupleType<T>::type;
};

void foo(C_TupleType tuple) { }

int main() {
    constexpr auto test = std::make_tuple(Type<int>{}, Type<double>{});
    foo(test);

    // also works on pair and array
    constexpr auto test1 = std::make_pair(Type<int>{}, Type<double>{});
    foo(test1);
    constexpr std::array<Type<int>, 3> test2;
    foo(test2);

    // and of course TupleType is also a meta type
    constexpr std::array<TupleType<std::pair<int, int>>, 13> test3;
    foo(test3);

    return 0;
}