18 Concepts library [concepts]

18.7 Callable concepts [concepts.callable]

18.7.1 General [concepts.callable.general]

The concepts in subclause [concepts.callable] describe the requirements on function objects ([function.objects]) and their arguments.

18.7.2 Concept invocable [concept.invocable]

The invocable concept specifies a relationship between a callable type ([func.def]) F and a set of argument types Args... which can be evaluated by the library function invoke ([func.invoke]).

🔗

template<class F, class... Args>
  concept invocable = requires(F&& f, Args&&... args) {
    invoke(std::forward<F>(f), std::forward<Args>(args)...); // not required to be equality-preserving
  };

[Example 1:

A function that generates random numbers can model invocable, since the invoke function call expression is not required to be equality-preserving ([concepts.equality]).

— end example]

18.7.3 Concept regular_invocable [concept.regularinvocable]

🔗

template<class F, class... Args>
  concept regular_invocable = invocable<F, Args...>;

The invoke function call expression shall be equality-preserving ([concepts.equality]) and shall not modify the function object or the arguments.

[Note 1:

This requirement supersedes the annotation in the definition of invocable .

— end note]

[Example 1:

A random number generator does not model regular_invocable .

— end example]

[Note 2:

The distinction between invocable and regular_invocable is purely semantic.

— end note]

18.7.4 Concept predicate [concept.predicate]

🔗

template<class F, class... Args>
  concept predicate =
    regular_invocable<F, Args...> && boolean-testable<invoke_result_t<F, Args...>>;

18.7.5 Concept relation [concept.relation]

🔗

template<class R, class T, class U>
  concept relation =
    predicate<R, T, T> && predicate<R, U, U> &&
    predicate<R, T, U> && predicate<R, U, T>;

18.7.6 Concept equivalence_relation [concept.equiv]

🔗

template<class R, class T, class U>
  concept equivalence_relation = relation<R, T, U>;

A relation models equivalence_relation only if it imposes an equivalence relation on its arguments.

18.7.7 Concept strict_weak_order [concept.strictweakorder]

🔗

template<class R, class T, class U>
  concept strict_weak_order = relation<R, T, U>;

A relation models strict_weak_order only if it imposes a strict weak ordering on its arguments.

The term strict refers to the requirement of an irreflexive relation (!comp(x, x) for all x), and the term weak to requirements that are not as strong as those for a total ordering, but stronger than those for a partial ordering.

If we define equiv(a, b) as !comp(a, b) && !comp(b, a), then the requirements are that comp and equiv both be transitive relations:

(2.1)
comp(a, b) && comp(b, c) implies comp(a, c)
(2.2)
equiv(a, b) && equiv(b, c) implies equiv(a, c)

[Note 1:

Under these conditions, it can be shown that

(3.1)
equiv is an equivalence relation,
(3.2)
comp induces a well-defined relation on the equivalence classes determined by equiv, and
(3.3)
the induced relation is a strict total ordering.

— end note]