\rSec0[exec]{Execution control library}

\rSec1[exec.general]{General}

This Clause describes components

supporting execution of function objects\iref{function.objects}.

The following subclauses describe

the requirements, concepts, and components

for execution control primitives as summarized in \tref{exec.summary}.

\begin{libsumtab}{Execution control library summary}{exec.summary}

\ref{exec.sched} & Schedulers & \tcode{<execution>} \\

\ref{exec.recv} & Receivers & \\

\ref{exec.opstate} & Operation states & \\

\ref{exec.snd} & Senders & \\

\end{libsumtab}

\tref{exec.pos} shows

the types of customization point objects\iref{customization.point.object}

used in the execution control library.

\begin{floattable}{Types of customization point objects in the execution control library}{exec.pos}{lx{0.23\hsize}x{0.45\hsize}}

\lhdr{Customization point} & \chdr{Purpose} & \rhdr{Examples} \\

\lhdr{object type} & & \\

core &

provide core execution functionality, and connection between core components &

e.g., \tcode{connect}, \tcode{start} \\

completion functions &

called by senders to announce the completion of the work (success, error, or cancellation) &

\tcode{set_value}, \tcode{set_error}, \tcode{set_stopped} \\

senders &

allow the specialization of the provided sender algorithms &

\begin{itemize}

\item sender factories (e.g., \tcode{schedule}, \tcode{just}, \tcode{read_env})

\item sender adaptors (e.g., \tcode{continues_on}, \tcode{then}, \tcode{let_value})

\item sender consumers (e.g., \tcode{sync_wait})

\end{itemize}

\\

queries &

allow querying different properties of objects &

\begin{itemize}

\item general queries (e.g., \tcode{get_allocator}, \tcode{get_stop_token})

\item environment queries (e.g., \tcode{get_scheduler}, \tcode{get_delegation_scheduler})

\item scheduler queries (e.g., \tcode{get_forward_progress_guarantee})

\item sender attribute queries (e.g., \tcode{get_completion_scheduler})

\end{itemize}

\\

\end{floattable}

This clause makes use of the following exposition-only entities.

For a subexpression \tcode{expr},

let \tcode{\exposid{MANDATE-NOTHROW}(expr)} be

expression-equivalent to \tcode{expr}.

\tcode{noexcept(expr)} is \tcode{true}.

\begin{codeblock}

namespace std {

template<class T>

concept @\defexposconcept{movable-value}@ = // \expos

@\libconcept{move_constructible}@<decay_t<T>> &&

@\libconcept{constructible_from}@<decay_t<T>, T> &&

(!is_array_v<remove_reference_t<T>>);

}

\end{codeblock}

For function types \tcode{F1} and \tcode{F2} denoting

\tcode{R1(Args1...)} and \tcode{R2(Args2...)}, respectively,

\tcode{\exposid{MATCHING-SIG}(F1, F2)} is \tcode{true} if and only if

\tcode{\libconcept{same_as}<R1(Args1\&\&...), R2(Args2\&\&...)>}

is \tcode{true}.

For a subexpression \tcode{err},

let \tcode{Err} be \tcode{decltype((err))} and

let \tcode{\exposid{AS-EXCEPT-PTR}(err)} be:

\begin{itemize}

\tcode{err} if \tcode{decay_t<Err>} denotes the type \tcode{exception_ptr}.

\tcode{!err} is \tcode{false}.

Otherwise,

\tcode{make_exception_ptr(system_error(err))}

if \tcode{decay_t<Err>} denotes the type \tcode{error_code}.

Otherwise, \tcode{make_exception_ptr(err)}.

\end{itemize}

For a subexpression \tcode{expr},

let \tcode{\exposid{AS-CONST}(expr)} be expression-equivalent to

\begin{codeblock}

[](const auto& x) noexcept -> const auto& { return x; }(expr)

\end{codeblock}

\rSec1[exec.queryable]{Queries and queryables}

\rSec2[exec.queryable.general]{General}

A \defnadj{queryable}{object} is

a read-only collection of key/value pair

where each key is a customization point object known as a \defn{query object}.

A \defn{query} is an invocation of a query object

with a queryable object as its first argument and

a (possibly empty) set of additional arguments.

A query imposes syntactic and semantic requirements on its invocations.

Let \tcode{q} be a query object,

let \tcode{args} be a (possibly empty) pack of subexpressions,

let \tcode{env} be a subexpression

that refers to a queryable object \tcode{o} of type \tcode{O}, and

let \tcode{cenv} be a subexpression referring to \tcode{o}

such that \tcode{decltype((cenv))} is \tcode{const O\&}.

The expression \tcode{q(env, args...)} is equal to\iref{concepts.equality}

the expression \tcode{q(cenv, args...)}.

The type of a query expression cannot be \tcode{void}.

The expression \tcode{q(env, args...)} is

equality-preserving\iref{concepts.equality} and

does not modify the query object or the arguments.

If the expression \tcode{env.query(q, args...)} is well-formed,

then it is expression-equivalent to \tcode{q(env, args...)}.

Unless otherwise specified,

the result of a query is valid as long as the queryable object is valid.

\rSec2[exec.queryable.concept]{\tcode{queryable} concept}

\begin{codeblock}

namespace std {

template<class T>

concept @\defexposconcept{queryable}@ = @\libconcept{destructible}@<T>; // \expos

}

\end{codeblock}

The exposition-only \exposconcept{queryable} concept specifies

the constraints on the types of queryable objects.

Let \tcode{env} be an object of type \tcode{Env}.

The type \tcode{Env} models \exposconcept{queryable}

if for each callable object \tcode{q} and a pack of subexpressions \tcode{args},

if \tcode{requires \{ q(env, args...) \}} is \tcode{true} then

\tcode{q(env, args...)} meets any semantic requirements imposed by \tcode{q}.

\rSec1[exec.async.ops]{Asynchronous operations}

An \defnadj{execution}{resource} is a program entity that manages

a (possibly dynamic) set of execution agents\iref{thread.req.lockable.general},

which it uses to execute parallel work on behalf of callers.

\begin{example}

The currently active thread,

a system-provided thread pool, and

uses of an API associated with an external hardware accelerator

are all examples of execution resources.

\end{example}

Execution resources execute asynchronous operations.

An execution resource is either valid or invalid.

An \defnadj{asynchronous}{operation} is

a distinct unit of program execution that

\begin{itemize}

is explicitly created;

can be explicitly started once at most;

once started, eventually completes exactly once

with a (possibly empty) set of result datums and

in exactly one of three \defnx{dispositions}{disposition}:

success, failure, or cancellation;

\begin{itemize}

A successful completion, also known as a \defnadj{value}{completion},

can have an arbitrary number of result datums.

A failure completion, also known as an \defnadj{error}{completion},

has a single result datum.

A cancellation completion, also known as a \defnadj{stopped}{completion},

has no result datum.

\end{itemize}

An asynchronous operation's \defnadj{async}{result}

is its disposition and its (possibly empty) set of result datums.

can complete on a different execution resource

than the execution resource on which it started; and

can create and start other asynchronous operations

called \defnadj{child}{operations}.

A child operation is an asynchronous operation

that is created by the parent operation and,

if started, completes before the parent operation completes.

A \defnadj{parent}{operation} is the asynchronous operation

that created a particular child operation.

\end{itemize}

\begin{note}

An asynchronous operation can execute synchronously;

that is, it can complete during the execution of its start operation

on the thread of execution that started it.

\end{note}

An asynchronous operation has associated state

known as its \defnadj{operation}{state}.

An asynchronous operation has an associated environment.

An \defn{environment} is a queryable object\iref{exec.queryable}

representing the execution-time properties of the operation's caller.

The caller of an asynchronous operation is

its parent operation or the function that created it.

An asynchronous operation has an associated receiver.

A \defn{receiver} is an aggregation of three handlers

for the three asynchronous completion dispositions:

\begin{itemize}

\item a value completion handler for a value completion,

\item an error completion handler for an error completion, and

\item a stopped completion handler for a stopped completion.

\end{itemize}

A receiver has an associated environment.

An asynchronous operation's operation state owns the operation's receiver.

The environment of an asynchronous operation

is equal to its receiver's environment.

For each completion disposition, there is a \defnadj{completion}{function}.

A completion function is

a customization point object\iref{customization.point.object}

that accepts an asynchronous operation's receiver as the first argument and

the result datums of the asynchronous operation as additional arguments.

The value completion function invokes

the receiver's value completion handler with the value result datums;

likewise for the error completion function and the stopped completion function.

A completion function has

an associated type known as its \defnadj{completion}{tag}

that is the unqualified type of the completion function.

A valid invocation of a completion function is called

a \defnadj{completion}{operation}.

The \defn{lifetime of an asynchronous operation},

also known as the operation's \defn{async lifetime},

begins when its start operation begins executing and

ends when its completion operation begins executing.

If the lifetime of an asynchronous operation's associated operation state

ends before the lifetime of the asynchronous operation,

the behavior is undefined.

After an asynchronous operation executes a completion operation,

its associated operation state is invalid.

Accessing any part of an invalid operation state is undefined behavior.

An asynchronous operation shall not execute a completion operation

before its start operation has begun executing.

After its start operation has begun executing,

exactly one completion operation shall execute.

The lifetime of an asynchronous operation's operation state can end

during the execution of the completion operation.

A \defn{sender} is a factory for one or more asynchronous operations.

\defnx{Connecting}{connect} a sender and a receiver creates

an asynchronous operation.

The asynchronous operation's associated receiver is equal to

the receiver used to create it, and

its associated environment is equal to

the environment associated with the receiver used to create it.

The lifetime of an asynchronous operation's associated operation state

does not depend on the lifetimes of either the sender or the receiver

from which it was created.

A sender is started when it is connected to a receiver and

the resulting asynchronous operation is started.

A sender's async result is the async result of the asynchronous operation

created by connecting it to a receiver.

A sender sends its results by way of the asynchronous operation(s) it produces,

and a receiver receives those results.

A sender is either valid or invalid;

it becomes invalid when its parent sender (see below) becomes invalid.

A \defn{scheduler} is an abstraction of an execution resource

with a uniform, generic interface for scheduling work onto that resource.

It is a factory for senders

whose asynchronous operations execute value completion operations

on an execution agent belonging to

the scheduler's associated execution resource.

A \defn{schedule-expression} obtains such a sender from a scheduler.

A \defn{schedule sender} is the result of a schedule expression.

On success, an asynchronous operation produced by a schedule sender executes

a value completion operation with an empty set of result datums.

Multiple schedulers can refer to the same execution resource.

A scheduler can be valid or invalid.

A scheduler becomes invalid when the execution resource to which it refers

becomes invalid,

as do any schedule senders obtained from the scheduler, and

any operation states obtained from those senders.

An asynchronous operation has one or more associated completion schedulers

for each of its possible dispositions.

A \defn{completion scheduler} is a scheduler

whose associated execution resource is used to execute

a completion operation for an asynchronous operation.

A value completion scheduler is a scheduler

on which an asynchronous operation's value completion operation can execute.

Likewise for error completion schedulers and stopped completion schedulers.

A sender has an associated queryable object\iref{exec.queryable}

known as its \defnx{attributes}{attribute}

that describes various characteristics of the sender and

of the asynchronous operation(s) it produces.

For each disposition,

there is a query object for reading the associated completion scheduler

from a sender's attributes;

i.e., a value completion scheduler query object

for reading a sender's value completion scheduler, etc.

If a completion scheduler query is well-formed,

the returned completion scheduler is unique

for that disposition for any asynchronous operation the sender creates.

A schedule sender is required to have a value completion scheduler attribute

whose value is equal to the scheduler that produced the schedule sender.

A \defn{completion signature} is a function type

that describes a completion operation.

An asynchronous operation has a finite set of possible completion signatures

corresponding to the completion operations

that the asynchronous operation potentially evaluates\iref{basic.def.odr}.

For a completion function \tcode{set},

receiver \tcode{rcvr}, and

pack of arguments \tcode{args},

let \tcode{c} be the completion operation \tcode{set(rcvr, args...)}, and

let \tcode{F} be

the function type \tcode{decltype(auto(set))(decltype((args))...)}.

A completion signature \tcode{Sig} is associated with \tcode{c}

if and only if

\tcode{\exposid{MATCHING-SIG}(Sig, F)} is \tcode{true}\iref{exec.general}.

Together, a sender type and an environment type \tcode{Env} determine

the set of completion signatures of an asynchronous operation

that results from connecting the sender with a receiver

that has an environment of type \tcode{Env}.

The type of the receiver does not affect

an asynchronous operation's completion signatures,

only the type of the receiver's environment.

A \defnadj{non-dependent}{sender} is a sender type

whose completion signatures are knowable

independent of an execution environment.

A sender algorithm is a function that takes and/or returns a sender.

There are three categories of sender algorithms:

\begin{itemize}

A \defn{sender factory} is a function

that takes non-senders as arguments and that returns a sender.

A \defn{sender adaptor} is a function

that constructs and returns a parent sender

from a set of one or more child senders and

a (possibly empty) set of additional arguments.

An asynchronous operation created by a parent sender is

a parent operation to the child operations created by the child senders.

A \defn{sender consumer} is a function

that takes one or more senders and

a (possibly empty) set of additional arguments, and

whose return type is not the type of a sender.

\end{itemize}

\rSec1[execution.syn]{Header \tcode{<execution>} synopsis}

\indexheader{execution}%

\begin{codeblock}

namespace std {

// \ref{execpol.type}, execution policy type trait

template<class T> struct is_execution_policy; // freestanding

template<class T> constexpr bool @\libglobal{is_execution_policy_v}@ = // freestanding

is_execution_policy<T>::value;

}

namespace std::execution {

// \ref{execpol.seq}, sequenced execution policy

class sequenced_policy;

// \ref{execpol.par}, parallel execution policy

class parallel_policy;

// \ref{execpol.parunseq}, parallel and unsequenced execution policy

class parallel_unsequenced_policy;

// \ref{execpol.unseq}, unsequenced execution policy

class unsequenced_policy;

// \ref{execpol.objects}, execution policy objects

inline constexpr sequenced_policy seq{ @\unspec@ };

inline constexpr parallel_policy par{ @\unspec@ };

inline constexpr parallel_unsequenced_policy par_unseq{ @\unspec@ };

inline constexpr unsequenced_policy unseq{ @\unspec@ };

}

namespace std {

// \ref{exec.general}, helper concepts

template<class T>

concept @\exposconceptnc{movable-value}@ = @\seebelownc@; // \expos

template<class From, class To>

concept @\defexposconceptnc{decays-to}@ = @\libconcept{same_as}@<decay_t<From>, To>; // \expos

template<class T>

concept @\defexposconceptnc{class-type}@ = @\exposconceptnc{decays-to}@<T, T> && is_class_v<T>; // \expos

// \ref{exec.queryable}, queryable objects

template<class T>

concept @\exposconceptnc{queryable}@ = @\seebelownc@; // \expos

// \ref{exec.queries}, queries

struct @\libglobal{forwarding_query_t}@ { @\unspec@ };

struct @\libglobal{get_allocator_t}@ { @\unspec@ };

struct @\libglobal{get_stop_token_t}@ { @\unspec@ };

inline constexpr forwarding_query_t @\libglobal{forwarding_query}@{};

inline constexpr get_allocator_t @\libglobal{get_allocator}@{};

inline constexpr get_stop_token_t @\libglobal{get_stop_token}@{};

template<class T>

using stop_token_of_t = remove_cvref_t<decltype(get_stop_token(declval<T>()))>;

template<class T>

concept @\defexposconceptnc{forwarding-query}@ = forwarding_query(T{}); // \expos

}

namespace std::execution {

// \ref{exec.queries}, queries

struct @\libglobal{get_domain_t}@ { @\unspec@ };

struct @\libglobal{get_scheduler_t}@ { @\unspec@ };

struct @\libglobal{get_delegation_scheduler_t}@ { @\unspec@ };

struct @\libglobal{get_forward_progress_guarantee_t}@ { @\unspec@ };

template<class CPO>

struct @\libglobal{get_completion_scheduler_t}@ { @\unspec@ };

struct get_await_completion_adaptor_t { @\unspec@ };

inline constexpr get_domain_t @\libglobal{get_domain}@{};

inline constexpr get_scheduler_t @\libglobal{get_scheduler}@{};

inline constexpr get_delegation_scheduler_t @\libglobal{get_delegation_scheduler}@{};

enum class forward_progress_guarantee;

inline constexpr get_forward_progress_guarantee_t @\libglobal{get_forward_progress_guarantee}@{};

template<class CPO>

constexpr get_completion_scheduler_t<CPO> @\libglobal{get_completion_scheduler}@{};

inline constexpr get_await_completion_adaptor_t get_await_completion_adaptor{};

struct @\libglobal{get_env_t}@ { @\unspec@ };

inline constexpr get_env_t @\libglobal{get_env}@{};

template<class T>

using @\libglobal{env_of_t}@ = decltype(get_env(declval<T>()));

// \ref{exec.prop}, class template \tcode{prop}

template<class QueryTag, class ValueType>

struct prop;

// \ref{exec.env}, class template \tcode{env}

template<@\exposconcept{queryable}@... Envs>

struct env;

// \ref{exec.domain.default}, execution domains

struct default_domain;

// \ref{exec.sched}, schedulers

struct @\libglobal{scheduler_t}@ {};

template<class Sch>

concept @\libconcept{scheduler}@ = @\seebelow@;

// \ref{exec.recv}, receivers

struct @\libglobal{receiver_t}@ {};

template<class Rcvr>

concept @\libconcept{receiver}@ = @\seebelow@;

template<class Rcvr, class Completions>

concept @\libconcept{receiver_of}@ = @\seebelow@;

struct @\libglobal{set_value_t}@ { @\unspec@ };

struct @\libglobal{set_error_t}@ { @\unspec@ };

struct @\libglobal{set_stopped_t}@ { @\unspec@ };

inline constexpr set_value_t @\libglobal{set_value}@{};

inline constexpr set_error_t @\libglobal{set_error}@{};

inline constexpr set_stopped_t @\libglobal{set_stopped}@{};

// \ref{exec.opstate}, operation states

struct @\libglobal{operation_state_t}@ {};

template<class O>

concept @\libconcept{operation_state}@ = @\seebelow@;

struct @\libglobal{start_t}@;

inline constexpr start_t @\libglobal{start}@{};

// \ref{exec.snd}, senders

struct @\libglobal{sender_t}@ {};

template<class Sndr>

concept @\libconcept{sender}@ = @\seebelow@;

template<class Sndr, class... Env>

concept @\libconcept{sender_in}@ = @\seebelow@;

template<class Sndr>

concept @\libconcept{dependent_sender}@ = @\seebelow@;

template<class Sndr, class Rcvr>

concept @\libconcept{sender_to}@ = @\seebelow@;

template<class... Ts>

struct @\exposidnc{type-list}@; // \expos

template<class... Ts>

using @\exposidnc{decayed-tuple}@ = tuple<decay_t<Ts>...>; // \expos

template<class... Ts>

using @\exposidnc{variant-or-empty}@ = @\seebelownc@; // \expos

template<class Sndr, class Env = env<>,

template<class...> class Tuple = @\exposid{decayed-tuple}@,

template<class...> class Variant = @\exposid{variant-or-empty}@>

requires @\libconcept{sender_in}@<Sndr, Env>

using value_types_of_t = @\seebelow@;

template<class Sndr, class Env = env<>,

template<class...> class Variant = @\exposid{variant-or-empty}@>

requires @\libconcept{sender_in}@<Sndr, Env>

using error_types_of_t = @\seebelow@;

template<class Sndr, class Env = env<>>

requires @\libconcept{sender_in}@<Sndr, Env>

constexpr bool sends_stopped = @\seebelow@;

template<class Sndr, class... Env>

using @\exposidnc{single-sender-value-type}@ = @\seebelownc@; // \expos

template<class Sndr, class... Env>

concept @\exposconcept{single-sender}@ = @\seebelow@; // \expos

template<@\libconcept{sender}@ Sndr>

using tag_of_t = @\seebelow@;

// \ref{exec.snd.transform}, sender transformations

template<class Domain, @\libconcept{sender}@ Sndr, @\exposconcept{queryable}@... Env>

requires (sizeof...(Env) <= 1)

constexpr @\libconcept{sender}@ decltype(auto) transform_sender(

Domain dom, Sndr&& sndr, const Env&... env) noexcept(@\seebelow@);

// \ref{exec.snd.transform.env}, environment transformations

template<class Domain, @\libconcept{sender}@ Sndr, @\exposconcept{queryable}@ Env>

constexpr @\exposconcept{queryable}@ decltype(auto) transform_env(

Domain dom, Sndr&& sndr, Env&& env) noexcept;

// \ref{exec.snd.apply}, sender algorithm application

template<class Domain, class Tag, @\libconcept{sender}@ Sndr, class... Args>

constexpr decltype(auto) apply_sender(

Domain dom, Tag, Sndr&& sndr, Args&&... args) noexcept(@\seebelow@);

// \ref{exec.connect}, the connect sender algorithm

struct @\libglobal{connect_t}@;

inline constexpr connect_t @\libglobal{connect}@{};

template<class Sndr, class Rcvr>

using @\libglobal{connect_result_t}@ =

decltype(connect(declval<Sndr>(), declval<Rcvr>()));

// \ref{exec.factories}, sender factories

struct @\libglobal{just_t}@ { @\unspec@ };

struct @\libglobal{just_error_t}@ { @\unspec@ };

struct @\libglobal{just_stopped_t}@ { @\unspec@ };

struct @\libglobal{schedule_t}@ { @\unspec@ };

inline constexpr just_t @\libglobal{just}@{};

inline constexpr just_error_t @\libglobal{just_error}@{};

inline constexpr just_stopped_t @\libglobal{just_stopped}@{};

inline constexpr schedule_t @\libglobal{schedule}@{};

inline constexpr @\unspec@ @\libglobal{read_env}@{};

template<@\libconcept{scheduler}@ Sch>

using @\libglobal{schedule_result_t}@ = decltype(schedule(declval<Sch>()));

// \ref{exec.adapt}, sender adaptors

template<@\exposconcept{class-type}@ D>

struct @\libglobal{sender_adaptor_closure}@ { };

struct @\libglobal{starts_on_t}@ { @\unspec@ };

struct @\libglobal{continues_on_t}@ { @\unspec@ };

struct @\libglobal{on_t}@ { @\unspec@ };

struct @\libglobal{schedule_from_t}@ { @\unspec@ };

struct @\libglobal{then_t}@ { @\unspec@ };

struct @\libglobal{upon_error_t}@ { @\unspec@ };

struct @\libglobal{upon_stopped_t}@ { @\unspec@ };

struct @\libglobal{let_value_t}@ { @\unspec@ };

struct @\libglobal{let_error_t}@ { @\unspec@ };

struct @\libglobal{let_stopped_t}@ { @\unspec@ };

struct @\libglobal{bulk_t}@ { @\unspec@ };

struct @\libglobal{bulk_chunked_t}@ { @\unspec@ };

struct @\libglobal{bulk_unchunked_t}@ { @\unspec@ };

struct @\libglobal{when_all_t}@ { @\unspec@ };

struct @\libglobal{when_all_with_variant_t}@ { @\unspec@ };

struct @\libglobal{into_variant_t}@ { @\unspec@ };

struct @\libglobal{stopped_as_optional_t}@ { @\unspec@ };

struct @\libglobal{stopped_as_error_t}@ { @\unspec@ };

struct @\libglobal{associate_t}@ { @\unspec@ };

struct @\libglobal{spawn_future_t}@ { @\unspec@ };

inline constexpr @\unspec@ @\libglobal{write_env}@{};

inline constexpr @\unspec@ @\libglobal{unstoppable}@{};

inline constexpr starts_on_t @\libglobal{starts_on}@{};

inline constexpr continues_on_t @\libglobal{continues_on}@{};

inline constexpr on_t @\libglobal{on}@{};

inline constexpr schedule_from_t @\libglobal{schedule_from}@{};

inline constexpr then_t @\libglobal{then}@{};

inline constexpr upon_error_t @\libglobal{upon_error}@{};

inline constexpr upon_stopped_t @\libglobal{upon_stopped}@{};

inline constexpr let_value_t @\libglobal{let_value}@{};

inline constexpr let_error_t @\libglobal{let_error}@{};

inline constexpr let_stopped_t @\libglobal{let_stopped}@{};

inline constexpr bulk_t @\libglobal{bulk}@{};

inline constexpr bulk_chunked_t @\libglobal{bulk_chunked}@{};

inline constexpr bulk_unchunked_t @\libglobal{bulk_unchunked}@{};

inline constexpr when_all_t @\libglobal{when_all}@{};

inline constexpr when_all_with_variant_t @\libglobal{when_all_with_variant}@{};

inline constexpr into_variant_t @\libglobal{into_variant}@{};

inline constexpr stopped_as_optional_t @\libglobal{stopped_as_optional}@{};

inline constexpr stopped_as_error_t @\libglobal{stopped_as_error}@{};

inline constexpr associate_t @\libglobal{associate}@{};

inline constexpr spawn_future_t @\libglobal{spawn_future}@{};

// \ref{exec.cmplsig}, completion signatures

template<class Fn>

concept @\exposconceptnc{completion-signature}@ = @\seebelownc@; // \expos

template<@\exposconcept{completion-signature}@... Fns>

struct @\libglobal{completion_signatures}@;

template<class Sigs>

concept @\exposconceptnc{valid-completion-signatures}@ = @\seebelownc@; // \expos

struct dependent_sender_error : exception {};

// \ref{exec.getcomplsigs}

template<class Sndr, class... Env>

consteval auto get_completion_signatures() -> @\exposconcept{valid-completion-signatures}@ auto;

template<class Sndr, class... Env>

requires @\libconcept{sender_in}@<Sndr, Env...>

using completion_signatures_of_t = decltype(get_completion_signatures<Sndr, Env...>());

// \ref{exec.run.loop}, run_loop

class run_loop;

}

namespace std::this_thread {

// \ref{exec.consumers}, consumers

struct @\libglobal{sync_wait_t}@ { @\unspec@ };

struct @\libglobal{sync_wait_with_variant_t}@ { @\unspec@ };

inline constexpr sync_wait_t @\libglobal{sync_wait}@{};

inline constexpr sync_wait_with_variant_t @\libglobal{sync_wait_with_variant}@{};

}

namespace std::execution {

// \ref{exec.consumers}, consumers

struct @\libglobal{spawn_t}@ { @\unspec@ };

inline constexpr spawn_t spawn{};

// \ref{exec.as.awaitable}

struct @\libglobal{as_awaitable_t}@ { @\unspec@ };

inline constexpr as_awaitable_t @\libglobal{as_awaitable}@{};

// \ref{exec.with.awaitable.senders}

template<@\exposconcept{class-type}@ Promise>

struct with_awaitable_senders;

// \ref{exec.scope.concepts}, scope concepts

template<class Token>

concept @\libconcept{scope_token}@ = @\seebelow@;

// \ref{exec.scope.simple.counting}

class simple_counting_scope;

// \ref{exec.scope.counting}

class counting_scope;

}

namespace std::execution {

// \ref{exec.par.scheduler}, parallel scheduler

class @\libglobal{parallel_scheduler}@ { @\unspec@ };

parallel_scheduler get_parallel_scheduler();

}

// \ref{exec.sysctxrepl}, namespace \tcode{system_context_replaceability}

namespace std::execution::@\libglobal{system_context_replaceability}@ {

struct receiver_proxy;

struct bulk_item_receiver_proxy;

struct parallel_scheduler_backend;

shared_ptr<parallel_scheduler_backend> query_parallel_scheduler_backend();

}

namespace std::execution {

// \ref{exec.affine.on}

struct @\libglobal{affine_on_t}@ { @\unspec@ };

inline constexpr affine_on_t @\libglobal{affine_on}@{};

// \ref{exec.inline.scheduler}

class @\libglobal{inline_scheduler}@;

// \ref{exec.task.scheduler}

class @\libglobal{task_scheduler}@;

template<class E>

struct @\libglobal{with_error}@ {

using type = remove_cvref_t<E>;

type error;

};

template<class E>

with_error(E) -> with_error<E>;

template<@\libconcept{scheduler}@ Sch>

struct change_coroutine_scheduler {

using type = remove_cvref_t<Sch>;

type scheduler;

};

template<@\libconcept{scheduler}@ Sch>

change_coroutine_scheduler(Sch) -> change_coroutine_scheduler<Sch>;

// \ref{exec.task}

template<class T, class Environment>

class @\libglobal{task}@;

}

\end{codeblock}

The exposition-only type \tcode{\exposid{variant-or-empty}<Ts...>}

is defined as follows:

\begin{itemize}

If \tcode{sizeof...(Ts)} is greater than zero,

\tcode{\exposid{variant-or-empty}<Ts...>} denotes \tcode{variant<Us...>}

where \tcode{Us...} is the pack \tcode{decay_t<Ts>...}

with duplicate types removed.

Otherwise, \tcode{\exposid{variant-or-empty}<Ts...>} denotes

the exposition-only class type:

\begin{codeblock}

namespace std::execution {

struct @\exposidnc{empty-variant}@ { // \expos

@\exposidnc{empty-variant}@() = delete;

};

}

\end{codeblock}

\end{itemize}

For type \tcode{Sndr} and pack of types \tcode{Env},

let \tcode{CS} be \tcode{completion_signatures_of_t<Sndr, Env...>}.

Then \tcode{\exposid{single-sender-value-type}<Sndr, Env...>} is ill-formed

if \tcode{CS} is ill-formed or

if \tcode{sizeof...(Env) > 1} is \tcode{true};

otherwise, it is an alias for:

\begin{itemize}

\tcode{\exposid{gather-signatures}<set_value_t, CS, decay_t, type_identity_t>}

if that type is well-formed,

Otherwise, \tcode{void}

if \tcode{\exposid{gather-signatures}<set_value_t, CS, tuple, variant>} is

\tcode{variant<tuple<>>} or \tcode{variant<>},

Otherwise, \tcode{\exposid{gather-signatures}<set_value_t, CS, \exposid{decayed-tuple}, type_identity_t>}

if that\linebreak{} type is well-formed,

Otherwise, \tcode{\exposid{single-sender-value-type}<Sndr, Env...>} is ill-formed.

\end{itemize}

The exposition-only concept \exposconcept{single-sender} is defined as follows:

\begin{codeblock}

namespace std::execution {

template<class Sndr, class... Env>

concept @\defexposconcept{single-sender}@ = @\libconcept{sender_in}@<Sndr, Env...> &&

requires {

typename @\exposid{single-sender-value-type}@<Sndr, Env...>;

};

}

\end{codeblock}

A type satisfies and models the exposition-only concept

\defexposconcept{valid-completion-signatures} if

it is a specialization of the \tcode{completion_signatures} class template.

\rSec1[exec.queries]{Queries}

\rSec2[exec.fwd.env]{\tcode{forwarding_query}}

\tcode{forwarding_query} asks a query object

whether it should be forwarded through queryable adaptors.

The name \tcode{forwarding_query} denotes a query object.

For some query object \tcode{q} of type \tcode{Q},

\tcode{forwarding_query(q)} is expression-equivalent to:

\begin{itemize}

\tcode{\exposid{MANDATE-NOTHROW}(q.query(forwarding_query))}

if that expression is well-formed.

The expression above has type \tcode{bool} and

is a core constant expression if \tcode{q} is a core constant expression.

Otherwise, \tcode{true} if \tcode{\libconcept{derived_from}<Q, forwarding_query_t>} is \tcode{true}.

Otherwise, \tcode{false}.

\end{itemize}

\rSec2[exec.get.allocator]{\tcode{get_allocator}}

\tcode{get_allocator} asks a queryable object for its associated allocator.

The name \tcode{get_allocator} denotes a query object.

For a subexpression \tcode{env},

\tcode{get_allocator(env)} is expression-equivalent to

\tcode{\exposid{MANDATE-NOTHROW}(\exposid{AS-CONST}(env).query(get_allocator))}.

If the expression above is well-formed,

its type satisfies

\exposconcept{simple-allocator}\iref{allocator.requirements.general}.

\tcode{forwarding_query(get_allocator)} is a core constant expression and

has value \tcode{true}.

\rSec2[exec.get.stop.token]{\tcode{get_stop_token}}

\tcode{get_stop_token} asks a queryable object for an associated stop token.

The name \tcode{get_stop_token} denotes a query object.

For a subexpression \tcode{env},

\tcode{get_stop_token(env)} is expression-equivalent to:

\begin{itemize}

\tcode{\exposid{MANDATE-NOTHROW}(\exposid{AS-CONST}(env).query(get_stop_token))}

if that expression is well-formed.

The type of the expression above satisfies \libconcept{stoppable_token}.

Otherwise, \tcode{never_stop_token\{\}}.

\end{itemize}

\tcode{forwarding_query(get_stop_token)} is a core constant expression and

has value \tcode{true}.

\rSec2[exec.get.env]{\tcode{execution::get_env}}

\tcode{execution::get_env} is a customization point object.

For a subexpression \tcode{o},

\tcode{execution::get_env(o)} is expression-equivalent to:

\begin{itemize}

\tcode{\exposid{MANDATE-NOTHROW}(\exposid{AS-CONST}(o).get_env())}

if that expression is well-formed.

The type of the expression above satisfies

\exposconcept{queryable}\iref{exec.queryable}.

Otherwise, \tcode{env<>\{\}}.

\end{itemize}

The value of \tcode{get_env(o)} shall be valid while \tcode{o} is valid.

\begin{note}

When passed a sender object,

\tcode{get_env} returns the sender's associated attributes.

When passed a receiver,

\tcode{get_env} returns the receiver's associated execution environment.

\end{note}

\rSec2[exec.get.domain]{\tcode{execution::get_domain}}

\tcode{get_domain} asks a queryable object

for its associated execution domain tag.

The name \tcode{get_domain} denotes a query object.

For a subexpression \tcode{env},

\tcode{get_domain(env)} is expression-equivalent to

\tcode{\exposid{MANDATE-NOTHROW}(\exposid{AS-CONST}(env).query(get_domain))}.

\tcode{forwarding_query(execution::get_domain)} is

a core constant expression and has value \tcode{true}.

\rSec2[exec.get.scheduler]{\tcode{execution::get_scheduler}}

\tcode{get_scheduler} asks a queryable object for its associated scheduler.

The name \tcode{get_scheduler} denotes a query object.

For a subexpression \tcode{env},

\tcode{get_scheduler(env)} is expression-equivalent to

\tcode{\exposid{MANDATE-NOTHROW}(\exposid{AS-CONST}(env).query(get_scheduler))}.

If the expression above is well-formed,

its type satisfies \libconcept{scheduler}.

\tcode{forwarding_query(execution::get_scheduler)} is

a core constant expression and has value \tcode{true}.

\rSec2[exec.get.delegation.scheduler]{\tcode{execution::get_delegation_scheduler}}

\tcode{get_delegation_scheduler} asks a queryable object for a scheduler

that can be used to delegate work to

for the purpose of forward progress delegation\iref{intro.progress}.

The name \tcode{get_delegation_scheduler} denotes a query object.

For a subexpression \tcode{env},

\tcode{get_delegation_scheduler(env)} is expression-equivalent to

\tcode{\exposid{MANDATE-NOTHROW}(\exposid{AS-CONST}(env).query(get_delegation_scheduler))}.

If the expression above is well-formed,

its type satisfies \libconcept{scheduler}.

\tcode{forwarding_query(execution::get_delegation_scheduler)} is

a core constant expression and has value \tcode{true}.

\rSec2[exec.get.fwd.progress]{\tcode{execution::get_forward_progress_guarantee}}

\begin{codeblock}

namespace std::execution {

enum class @\libglobal{forward_progress_guarantee}@ {

concurrent,

parallel,

weakly_parallel

};

}

\end{codeblock}

\tcode{get_forward_progress_guarantee} asks a scheduler about

the forward progress guarantee of execution agents