Pasar un concepto a una función

Dado que los conceptos se definen como predicados en tiempo de compilación, ¿también es posible reutilizar estos predicados para algoritmos en tiempo de compilación? Por ejemplo, ¿sería posible verificar si todos los tipos de una tupla se ajustan a un concepto? Por lo que he visto, no es posible pasar un concepto a una función de ninguna manera, lo que me lleva de nuevo a usar plantillas para estos 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>());
}

Lo que me gustaría hacer es algo como esto, así que no tengo que envolver el concepto todo el tiempo para poder usarlo:

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>());
}

¿Hay alguna forma de acercarse a esto?

¿Hay alguna forma de acercarse a esto?

Bueno, no, en realidad no. No en C ++ 20. Actualmente no existe una noción en el lenguaje de una plantilla concepto-parámetro. Incluso las plantillas variables no se pueden usar como parámetros de plantilla. Entonces, si tenemos un concepto para comenzar, no podemos evitar el ajuste.

Pero lo que podemos hacer es escribir envoltorios más simples. Si aceptamos usar rasgos de tipo "estilo antiguo" como predicados, específicamente aquellos que se comportan como std::integral_constants, entonces podemos tener definiciones de "concepto" bastante concisas que pueden usarse como predicados.

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

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

Es tan bueno como puede llegar , hasta donde puedo ver.

Si su objetivo es "verificar si todos los tipos en una tupla se ajustan a un concepto" , puede hacer algo como esto:

// 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 EN VIVO