Passer d'un concept à une fonction

Puisque les concepts sont définis comme des prédicats au moment de la compilation, est-il également possible de réutiliser ces prédicats pour les algorithmes au moment de la compilation? Par exemple, serait-il possible de vérifier si tous les types d'un tuple sont conformes à un concept? Pour autant que je l'ai vu, il n'est pas possible de transmettre un concept à une fonction, ce qui me ramène à l'utilisation de modèles pour ces cas.

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

Ce que je voudrais faire, c'est quelque chose comme ça, donc je n'ai pas à envelopper le concept tout le temps pour pouvoir l'utiliser:

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-t-il un moyen de se rapprocher de cela?

Existe-t-il un moyen de se rapprocher de cela?

Eh bien non, pas vraiment. Pas en C ++ 20. Il n'y a aucune notion dans le langage actuel d'un modèle-paramètre de modèle. Même les modèles de variables ne peuvent pas être utilisés comme paramètres de modèle. Donc, si nous avons un concept pour commencer, nous ne pouvons pas éviter le wrapping.

Mais ce que nous pouvons faire, c'est écrire des enveloppes plus simples. Si nous acceptons d'utiliser des traits de type "à l'ancienne" comme prédicats, en particulier ceux qui se comportent comme des std::integral_constants, alors nous pouvons avoir des définitions de "concept" assez concises qui peuvent être utilisées comme prédicats.

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

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

C'est aussi bon que possible , pour autant que je puisse voir.

Si votre objectif est de "vérifier si tous les types d'un tuple sont conformes à un concept" , vous pouvez faire quelque chose comme ceci:

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

}

DÉMO EN DIRECT