概念可以要求constexpr值或函数吗？

Question

So, I'd like to do some advanced type-level hackery for which I would really like to be able to write a concept that requires a type to have a constexpr int value associated with it, which I can use later in the same concept as the integer std::array template parameter.

It's possible to write

template<typename T>
concept bool HasCount = requires {
    typename T::count;
};

but this is not what I want; I would like T::count to be a static constexpr int . However, the code (not even including the needed constexpr )

template<typename T>
concept bool HasCount = requires {
    int T::count;
};

does not compile with "error: expected primary-expression before 'int'" on GCC 7.3.0.

Another failed attempt: it's possible to write this, which would require static int T::count() :

template<typename T>
concept bool HasCount = requires {
    {T::count()} -> int;
};

but not this, which is what I want:

template<typename T>
concept bool HasCount = requires {
    {T::count()} -> constexpr int;
    {T::count() constexpr} -> int; // or this
    {constexpr T::count()} -> int; // or this (please forgive me for fuzzing GCC instead of reading the manual, unlike perl C++ is not an empirical science)
};

So, I'd like to know if it's in any way possible to require a concept expression to be constexpr-qualified, or if not if there's a reason why it can't be possible, or if it's just not included in the specification.

Answer 1

In theory, this is possible by requiring T::count to be a valid expression, and requiring that it's valid to use T::count in a context that requires a constant expression. For example:

#include <type_traits>
#include <utility>

template<int> using helper = void;

template<typename T>
concept bool HasCount = requires {
    // T::count must be a valid expression
    T::count;
    // T::count must have type int const
    requires std::is_same_v<int const, decltype(T::count)>;
    // T::count must be usable in a context that requires a constant expression
    typename ::helper<T::count>;
};

struct S1 {
    static constexpr int count = 42;
};
static_assert(HasCount<S1>);

struct S2 {
    int count = 42;
};
static_assert(!HasCount<S2>);

struct S3 {
    static constexpr double count = 3.14;
};
static_assert(!HasCount<S3>);

but in practice, the implementation of concepts in GCC rejects this program :

<source>:20:16: error: invalid use of non-static data member 'S2::count'
 static_assert(!HasCount<S2>);
                ^~~~~~~~~~~~
<source>:18:17: note: declared here
     int count = 42;
                 ^~
<source>:20:16: error: invalid use of non-static data member 'S2::count'
 static_assert(!HasCount<S2>);
                ^~~~~~~~~~~~
<source>:18:17: note: declared here
     int count = 42;
                 ^~

(which fact I believe to be a bug .)