Przekazywanie koncepcji do funkcji

Skoro pojęcia są zdefiniowane jako predykaty czasu kompilacji, czy możliwe jest również ponowne wykorzystanie tych predykatów dla algorytmów kompilacji? Czy na przykład można sprawdzić, czy wszystkie typy w krotce są zgodne z koncepcją? O ile widziałem, nie można w żaden sposób przekazać koncepcji do funkcji, co prowadzi mnie z powrotem do korzystania z szablonów w tych przypadkach.

#include <type_traits>

template<typename T>
concept FloatLike = std::is_same_v<T, float>;

struct IsFloat
{
    template<typename U>
    constexpr static bool test()
    {
       return FloatLike<U>;
    }
};


template<typename Predicate, typename... T>
constexpr bool all_types()
{
    return (Predicate::template test<T>() && ...);
}


int main()
{
   static_assert(all_types<IsFloat, float, float>());
   static_assert(!all_types<IsFloat, float, int>());
}

Chciałbym coś takiego, więc nie muszę cały czas owijać koncepcji, aby móc z niej skorzystać:

template<concept Predicate, typename... T>
constexpr bool all_types()
{
    return (Predicate<T> && ...);
}


int main()
{
   static_assert(all_types<FloatLike, float, float>());
   static_assert(!all_types<FloatLike, float, int>());
}

Czy jest jakiś sposób, aby się do tego zbliżyć?

Czy jest jakiś sposób, aby się do tego zbliżyć?

Nie, nie bardzo. Nie w C ++ 20. W dzisiejszym języku nie ma pojęcia o szablonie-parametrze. Nawet szablonów zmiennych nie można używać jako parametrów szablonów. Więc jeśli mamy pomysł na początek, nie możemy uniknąć owijania.

Ale możemy zrobić prostsze opakowania. Jeśli zgodzimy się używać cech typu „starego stylu” jako predykatów, szczególnie tych, które zachowują się jak std::integral_constants, wówczas możemy mieć dość zwięzłe definicje „koncepcyjne”, które mogą być używane jako predykaty.

template<typename T>
using FloatLike = std::is_same<T, float>;

template<template <typename> class Predicate, typename... T>
constexpr bool all_types()
{
    return (Predicate<T>{} && ...);
}

O ile mi wiadomo, jest tak dobry, jak to tylko możliwe.

Jeśli Twoim celem jest „sprawdzenie, czy wszystkie typy w krotce są zgodne z koncepcją” , możesz zrobić coś takiego:

// concept to check if all types in Ts are the same as T
template<typename T, typename... Ts>
concept AllSame = (std::is_same_v<T,Ts> && ...);

// function only accepts floats as template parameters
template<AllSame<float>... Floats>
constexpr void float_foo()
{
}

// function only accepts ints as template parameters
template<AllSame<int>... Ints>
constexpr void int_foo()
{
}

// function only accepts T as template parameters
template<typename T, AllSame<T>... Ts>
constexpr void foo()
{
}

int main()
{
    int_foo<int, int, int>();
    // int_foo<int, int, double>(); // fails to compile
    float_foo<float, float, float>();
    // float_foo<float, float, int>(); // fails to compile
    foo<int, int, int, int>();
    // foo<int, int, int, float>(); // fails to compile
    foo<double, double, double, double>();
    // foo<double, double, double, int>(); // fails to compile

}

DEMO NA ŻYWO