Como os conceitos são definidos como predicados em tempo de compilação, também é possível realmente reutilizá-los para algoritmos em tempo de compilação? Por exemplo, seria possível verificar se todos os tipos em uma tupla estão em conformidade com um conceito? Até onde eu vi, não é possível passar um conceito para uma função de forma alguma, o que me leva a voltar a usar modelos para esses casos.
#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>());
}
O que eu gostaria de fazer é algo assim, então não preciso envolver o conceito o tempo todo para poder usá-lo:
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>());
}
Existe alguma maneira de se aproximar disso?
all_types()
pode ser significativamente simplificado usando expressões de dobra... &&
:return (... && Predicate::template test<Ts>());