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

template<class Rcvr, class Completions>

template<class Rcvr, class ChildOp>

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

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

template<class Sndr, class Rcvr>

template<class... Ts>

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

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

template<class Sndr, class... Env>

template<@\libconcept{sender}@ Sndr>

using tag_of_t = @\seebelow@;

Given subexpressions \tcode{sndr} and \tcode{rcvr}

and the expression \tcode{get_start_scheduler(get_env(rcvr))} is well-formed,

an operation state that is the result of calling \tcode{connect(sndr, rcvr)}

shall, if it is started, be started on an execution agent

A receiver represents the continuation of an asynchronous operation.

The \libconcept{receiver} concept defines

the requirements for a receiver type\iref{exec.async.ops}.

the requirements for a receiver type that is usable as

the first argument of a set of completion operations

corresponding to a set of completion signatures.

};

template<class Rcvr, class Completions>

@\libconcept{receiver}@<Rcvr> && @\exposconcept{has-completions}@<Rcvr, Completions>;

}

\end{codeblock}

let \tcode{Sndr} be \tcode{decltype((sndr))}.

Let \tcode{rcvr} be a receiver of type \tcode{Rcvr}

with associated environment \tcode{env} of type \tcode{Env}

For the default implementation of the algorithm that produced \tcode{sndr},

connecting \tcode{sndr} to \tcode{rcvr} and

starting the resulting operation state\iref{exec.async.ops}

The \libconcept{sender_in} concept defines

the requirements for a sender type

that can create asynchronous operations given an associated environment type.

the requirements for a sender type

that can connect with a specific receiver type.

The \tcode{get_env} customization point object is used to access

@\libconcept{sender}@<Sndr> && bool_constant<@\exposid{is-dependent-sender-helper}@<Sndr>()>::value;

template<class Sndr, class Rcvr>

@\libconcept{sender_in}@<Sndr, env_of_t<Rcvr>> &&

requires (Sndr&& sndr, Rcvr&& rcvr) {

connect(std::forward<Sndr>(sndr), std::forward<Rcvr>(rcvr));

};

return awaiter{fn};

}

exception_ptr ep;

try {

if constexpr (@\libconcept{same_as}@<V, void>) {

\tcode{\libconcept{sender_in}<Sndr, env_of_t<Rcvr>>}

\end{itemize}

\rSec2[exec.factories]{Sender factories}

For a subexpression \tcode{sndr}, let \tcode{Sndr} be \tcode{decltype((sndr))}.

is \tcode{false},

the expression \tcode{sync_wait.apply_sender(sndr)} is ill-formed;

otherwise, it is equivalent to:

Let \exposid{sndr} be an expression of type \exposid{run-loop-sender},

let \exposid{rcvr} be an expression

where \tcode{CS} is the \tcode{completion_signatures} specialization above.

Let \tcode{C} be either \tcode{set_value_t} or \tcode{set_stopped_t}.

Then:

template<class Sndr, class Promise>

concept @\defexposconcept{awaitable-sender}@ =

@\exposconcept{single-sender}@<Sndr, env_of_t<Promise>> &&

typename @\exposid{sender-awaitable}@<Sndr, Promise>::@\exposid{awaitable-receiver}@> && // \seebelow

requires (Promise& p) {

{ p.unhandled_stopped() } -> @\libconcept{convertible_to}@<coroutine_handle<>>;

Let \tcode{sndr} be an expression of type \exposid{inline-sender},

let \tcode{rcvr} be an expression such that

where \tcode{CS} is \tcode{completion_signatures<set_value_t()>},

then the expression \tcode{connect(sndr, rcvr)} has

type \tcode{\exposid{inline-state}<remove_cvref_t<decltype((rcvr))>>}