C++ nécessite une expression avec une vérification de concept de type de retour inversé

Question

Je essaie de définir un concept avec une expression require qui vérifie l'existence de certaines fonctions membres sur le type.
Le problème auquel je suis confronté est qu'un seul concept doit être branché pour vérifier le type de retour sans aucune opération booléenne précédente comme "not". Cela me force également à écrire des concepts pour l'inverse si nécessaire, ce qui n'est pas vraiment pratique.
Est-ce que quelque chose m'échappe ou y a-t-il une autre bonne manière de le faire?

Exemple simple:

template 
concept EstReference = std::is_reference_v;

template 
concept AuneFonction = requires (T t) {
    {t.func()} -> EstReference; /* c'est correct */
    {t.anotherFunc()} -> (not EstReference); /* ce n'est pas correct */
};

Answer 1

Voici une syntaxe qui fonctionne sur les dernières versions de gcc et de clang.

template <typename T>
concept HasSomeFunction = requires (T t) {
    {t.func()} -> IsReference; /* this is ok */
    requires !IsReference<decltype(t.anotherFunc())>;
};

Démo

C'est un peu plus difficile à lire. Peut-être que quelqu'un ayant une expérience plus importante avec les concepts pourra fournir une meilleure solution.

Answer 2

Essayez ceci

#include 
#include 

struct B {};
struct D : B {};

template 
concept IsReference = std::is_reference_v;
template 
concept NotIsReference = !std::is_reference_v;

template 
concept HasSomeFunction = requires (T t) {
    {t.func()} -> IsReference; /* this is ok */
    {t.anotherFunc()} -> NotIsReference; /* this is not ok */
};

int main() {
    std::shared_ptr b = std::make_shared();
    auto d = static_pointer_cast(b);
    assert(d);
}