[support.coroutine] (original) (raw)
17 Language support library [support]
17.12 Coroutines [support.coroutine]
The header <coroutine>defines several types providing compile and run-time support for coroutines in a C++ program.
17.12.1 Header synopsis [coroutine.syn]
#include
namespace std {
template<class R, class... ArgTypes> struct coroutine_traits;
template struct coroutine_handle;
constexpr bool operator==(coroutine_handle<> x, coroutine_handle<> y) noexcept; constexpr strong_ordering operator<=>(coroutine_handle<> x, coroutine_handle<> y) noexcept;
template struct hash; template struct hash<coroutine_handle
>;
struct noop_coroutine_promise;
template<> struct coroutine_handle; using noop_coroutine_handle = coroutine_handle;
noop_coroutine_handle noop_coroutine() noexcept;
struct suspend_never; struct suspend_always; }
17.12.2 Coroutine traits [coroutine.traits]
This subclause defines requirements on classes representingcoroutine traits, and defines the class templatecoroutine_traitsthat meets those requirements.
17.12.2.1 Class template coroutine_traits [coroutine.traits.primary]
The header <coroutine> defines the primary templatecoroutine_traits such that if ArgTypes is a parameter pack of types and if the qualified-id R::promise_type is valid and denotes a type ([temp.deduct]), then coroutine_traits<R,ArgTypes...> has the following publicly accessible member:
using promise_type = typename R::promise_type;
Otherwise, coroutine_traits<R,ArgTypes...> has no members.
Program-defined specializations of this template shall define a publicly accessible nested type named promise_type.
17.12.3 Class template coroutine_handle [coroutine.handle]
namespace std { template<> struct coroutine_handle {
constexpr coroutine_handle() noexcept;
constexpr coroutine_handle(nullptr_t) noexcept;
coroutine_handle& operator=(nullptr_t) noexcept;
constexpr void* address() const noexcept;
static constexpr coroutine_handle from_address(void* addr);
constexpr explicit operator bool() const noexcept;
bool done() const;
void operator()() const;
void resume() const;
void destroy() const; private:
void* ptr;
};
template struct coroutine_handle : coroutine_handle<> {
using coroutine_handle<>::coroutine_handle;
static coroutine_handle from_promise(Promise&);
coroutine_handle& operator=(nullptr_t) noexcept;
static constexpr coroutine_handle from_address(void* addr);
Promise& promise() const;}; }
An object of typecoroutine_handle<T> is called a coroutine handleand can be used to refer to a suspended or executing coroutine.
A default-constructed coroutine_handle object does not refer to any coroutine.
If a program declares an explicit or partial specialization ofcoroutine_handle, the behavior is undefined.
17.12.3.1 Construct/reset [coroutine.handle.con]
constexpr coroutine_handle() noexcept;constexpr coroutine_handle(nullptr_t) noexcept;
Postconditions: address() == nullptr.
static coroutine_handle from_promise(Promise& p);
Preconditions: p is a reference to a promise object of a coroutine.
Returns:A coroutine handle h referring to the coroutine.
Postconditions: addressof(h.promise()) == addressof(p).
coroutine_handle& operator=(nullptr_t) noexcept;
Postconditions: address() == nullptr.
17.12.3.2 Export/import [coroutine.handle.export.import]
constexpr void* address() const noexcept;
static constexpr coroutine_handle<> coroutine_handle<>::from_address(void* addr);static constexpr coroutine_handle<Promise> coroutine_handle<Promise>::from_address(void* addr);
Preconditions: addr was obtained via a prior call to address.
Postconditions: from_address(address()) == *this.
17.12.3.3 Observers [coroutine.handle.observers]
constexpr explicit operator bool() const noexcept;
Returns: address() != nullptr.
Preconditions: *this refers to a suspended coroutine.
Returns: true if the coroutine is suspended at its final suspend point, otherwise false.
17.12.3.4 Resumption [coroutine.handle.resumption]
Resuming a coroutine via resume, operator(), or destroyon an execution agent other than the one on which it was suspended has implementation-defined behavior unless each execution agent either is an instance of std::thread or std::jthread, or is the thread that executes main.
[ Note
:
A coroutine that is resumed on a different execution agent should avoid relying on consistent thread identity throughout, such as holding a mutex object across a suspend point.
— end note
]
[ Note
:
A concurrent resumption of the coroutine may result in a data race.
— end note
]
void operator()() const;void resume() const;
Preconditions: *this refers to a suspended coroutine.
The coroutine is not suspended at its final suspend point.
Effects:Resumes the execution of the coroutine.
Preconditions: *this refers to a suspended coroutine.
17.12.3.5 Promise access [coroutine.handle.promise]
Promise& promise() const;
Preconditions: *this refers to a coroutine.
Returns:A reference to the promise of the coroutine.
17.12.3.6 Comparison operators [coroutine.handle.compare]
constexpr bool operator==(coroutine_handle<> x, coroutine_handle<> y) noexcept;
Returns: x.address() == y.address().
constexpr strong_ordering operator<=>(coroutine_handle<> x, coroutine_handle<> y) noexcept;
Returns: compare_three_way()(x.address(), y.address()).
17.12.4 No-op coroutines [coroutine.noop]
17.12.4.1 Class noop_coroutine_promise [coroutine.promise.noop]
struct noop_coroutine_promise {};
The class noop_coroutine_promise defines the promise type for the coroutine referred to by noop_coroutine_handle ([coroutine.syn]).
17.12.4.2 Class coroutine_handle<noop_coroutine_promise> [coroutine.handle.noop]
namespace std { template<> struct coroutine_handle : coroutine_handle<> {
constexpr explicit operator bool() const noexcept;
constexpr bool done() const noexcept;
constexpr void operator()() const noexcept;
constexpr void resume() const noexcept;
constexpr void destroy() const noexcept;
noop_coroutine_promise& promise() const noexcept;
constexpr void* address() const noexcept;private: coroutine_handle(unspecified); }; }
17.12.4.2.2 Resumption [coroutine.handle.noop.resumption]
constexpr void operator()() const noexcept;constexpr void resume() const noexcept;constexpr void destroy() const noexcept;
Remarks:If noop_coroutine_handle is converted to coroutine_handle<>, calls to operator(), resume and destroy on that handle will also have no observable effects.
17.12.4.2.3 Promise access [coroutine.handle.noop.promise]
noop_coroutine_promise& promise() const noexcept;
Returns:A reference to the promise object associated with this coroutine handle.
17.12.4.3 Function noop_coroutine [coroutine.noop.coroutine]
noop_coroutine_handle noop_coroutine() noexcept;
Returns:A handle to a coroutine that has no observable effects when resumed or destroyed.
Remarks:A handle returned from noop_coroutine may or may not compare equal to a handle returned from another invocation of noop_coroutine.
17.12.5 Trivial awaitables [coroutine.trivial.awaitables]
namespace std { struct suspend_never { constexpr bool await_ready() const noexcept { return true; } constexpr void await_suspend(coroutine_handle<>) const noexcept {} constexpr void await_resume() const noexcept {} }; struct suspend_always { constexpr bool await_ready() const noexcept { return false; } constexpr void await_suspend(coroutine_handle<>) const noexcept {} constexpr void await_resume() const noexcept {} }; }
[ Note
:
The types suspend_never and suspend_always can be used to indicate that an await-expression should either never suspend or always suspend, and in either case not produce a value.
— end note
]