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

return-type-requirement:trailing-return-type->type-constraint

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 noexcept specifier is present, E shall not be a potentially-throwing expression ([except.spec]).
- 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*([dcl.decl]), E is implicitly convertible to the type named by the*trailing-return-type*. - If the
*return-type-requirement*is of the form ->*type-constraint*, then the contextually-determined type being constrained is decltype((E)).

[ 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> concept C3 = requires(T x) { {g(x)} noexcept; };

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

—