compound-requirement: {expression} noexceptreturn-type-requirement;

return-type-requirement:trailing-return-type->cv-qualifier-seqconstrained-parametercv-qualifier-seqabstract-declarator

Substitution
of template arguments (if any) and verification of
semantic properties proceed in the following order:

- Substitution of template arguments (if any) into the
*expression*is performed. - If the
*return-type-requirement*is present, then:- Substitution of template arguments (if any) into the
*return-type-requirement*is performed. - If the
*return-type-requirement*is a*trailing-return-type*, E is implicitly convertible to the type named by the*trailing-return-type*. - If the
*return-type-requirement*starts with a*constrained-parameter*, the*expression*is deduced against an invented function template F using the rules in [temp.deduct.call].F is a void function template with a single type template parameter T declared with the*constrained-parameter*.A*cv-qualifier-seq*cv is formed as the union of const and volatile specifiers around the*constrained-parameter*.

[ Example

: *end example*

]template<typename T> concept C1 = requires(T x) { {x++}; };

template<typename T> concept C2 = requires(T x) { {*x} -> typename T::inner; };

The *compound-requirement* in C2
requires that *x is a valid expression,
that typename T::inner is a valid type, and
that *x is implicitly convertible to
typename T::inner.

template<typename T, typename U> concept C3 = requires (T t, U u) { t == u; }; template<typename T> concept C4 = requires(T x) { {*x} -> C3<int> const&; };

The *compound-requirement*
requires that *x be deduced
as an argument for the invented function:

template<C3<int> X> void f(X const&);

In this case, deduction only succeeds if
an expression of the type deduced for X
can be compared to an int
with the == operator.

template<typename T> concept C5 = requires(T x) { {g(x)} noexcept; };

The *compound-requirement* in C5
requires that g(x) is a valid expression and
that g(x) is non-throwing.

—