cppdraft_translate/cppdraft/exec/cmplsig.md

[exec.cmplsig]

33 Execution control library [exec]

33.10 Completion signatures [exec.cmplsig]

1

#

completion_signatures is a type that encodes a set of completion signatures ([exec.async.ops]).

2

#

[Example 1: struct my_sender {using sender_concept = sender_t; using completion_signatures = execution::completion_signatures< set_value_t(), set_value_t(int, float), set_error_t(exception_ptr), set_error_t(error_code), set_stopped_t()>;};

Declares my_sender to be a sender that can complete by calling one of the following for a receiver expression rcvr:

• (2.1)

set_value(rcvr)

• (2.2)

set_value(rcvr, int{...}, float{...})

• (2.3)

set_error(rcvr, exception_ptr{...})

• (2.4)

set_error(rcvr, error_code{...})

• (2.5)

set_stopped(rcvr)

— end example]

3

#

This subclause makes use of the following exposition-only entities:templateconcept completion-signature = see below;

4

#

A type Fn satisfies completion-signature if and only if it is a function type with one of the following forms:

• (4.1)

  set_value_t(Vs...), where Vs is a pack of object or reference types.

• (4.2)

  set_error_t(Err), where Err is an object or reference type.

• (4.3)

  set_stopped_t()

5

#

templatestruct indirect-meta-apply {template<template<class...> class T, class... As>using meta-apply = T<As...>; // exposition only};

template<class...>concept always-true = true; // exposition onlytemplate<class Tag, valid-completion-signatures Completions, template<class...> class Tuple, template<class...> class Variant>using gather-signatures = see below;

6

#

Let Fns be a pack of the arguments of the completion_signatures specialization named by Completions, let TagFns be a pack of the function types in Fns whose return types are Tag, and let Tsn be a pack of the function argument types in the n-th type in TagFns.

Then, given two variadic templates Tuple and Variant, the type gather-signatures<Tag, Completions, Tuple, Variant> names the typeMETA-APPLY(Variant, META-APPLY(Tuple, Ts0...), META-APPLY(Tuple, Ts1...), …, META-APPLY(Tuple, Tsm−1...)) where m is the size of the pack TagFns andMETA-APPLY(T, As...) is equivalent to:typename indirect-meta-apply<always-true<As...>>::template meta-apply<T, As...>

7

#

[Note 1:

The purpose of META-APPLY is to make it valid to use non-variadic templates as Variant and Tuple arguments to gather-signatures.

— end note]

8

#

🔗

namespace std::execution {template<completion-signature... Fns>struct completion_signatures {templatestatic constexpr size_t count-of(Tag) { return see below; }templatestatic constexpr void for-each(Fn&& fn) { // exposition only(std::forward(fn)(static_cast<Fns*>(nullptr)), ...); }}; template<class Sndr, class Env = env<>, template<class...> class Tuple = decayed-tuple, template<class...> class Variant = variant-or-empty>requires sender_in<Sndr, Env>using value_types_of_t =gather-signatures<set_value_t, completion_signatures_of_t<Sndr, Env>, Tuple, Variant>; template<class Sndr, class Env = env<>, template<class...> class Variant = variant-or-empty>requires sender_in<Sndr, Env>using error_types_of_t =gather-signatures<set_error_t, completion_signatures_of_t<Sndr, Env>, type_identity_t, Variant>; template<class Sndr, class Env = env<>>requires sender_in<Sndr, Env>constexpr bool sends_stopped =<type-list<>, gather-signatures<set_stopped_t, completion_signatures_of_t<Sndr, Env>, type-list, type-list>>;}

9

#

For a subexpression tag, let Tag be the decayed type of tag.

completion_signatures<Fns...>​::​count-of(
tag) returns the count of function types in Fns... that are of the form Tag(Ts...) where Ts is a pack of types.