Passare un concetto a una funzione

Poiché i concetti sono definiti come predicati in fase di compilazione, è anche possibile riutilizzare effettivamente questi predicati per algoritmi in fase di compilazione? Ad esempio, sarebbe possibile verificare se tutti i tipi in una tupla sono conformi a un concetto? Per quanto ho visto, non è possibile in alcun modo passare un concetto a una funzione, il che mi riporta all'utilizzo dei modelli per questi casi.

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

Quello che vorrei fare è qualcosa del genere, quindi non devo avvolgere il concetto continuamente per poterlo usare:

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

C'è un modo per avvicinarsi a questo?

C'è un modo per avvicinarsi a questo?

Beh, no, non proprio. Non in C ++ 20. Oggi non esiste alcuna nozione nella lingua di un modello concetto-parametro. Perfino i template variabili non possono essere usati come parametri template. Quindi, se abbiamo un concetto per cominciare, non possiamo evitare di avvolgere.

Ma quello che possiamo fare è scrivere wrapper più semplici. Se accettiamo di usare tratti di tipo "vecchio stile" come predicati, in particolare quelli che si comportano come std::integral_constants, allora possiamo avere definizioni di "concetto" piuttosto concise che possono essere usate come predicati.

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

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

È il massimo che posso ottenere , per quanto posso vedere.

Se il tuo obiettivo è "verificare se tutti i tipi in una tupla sono conformi a un concetto" , puoi fare qualcosa del genere:

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

}

DIMOSTRAZIONE DAL VIVO