std::coroutine_traits - cppreference.com (original) (raw)
| | | | | ------------------------------------------------------------- | | ------------- | | template< class R, class... Args > struct coroutine_traits; | | (since C++20) |
Determines the promise type from the return type and parameter types of a coroutine. The standard library implementation provides a publicly accessible member type promise_type same as R::promise_type if the qualified-id is valid and denotes a type. Otherwise, it has no such member.
Program-defined specializations of coroutine_traits must define a publicly accessible nested type promise_type, otherwise the program is ill-formed.
[edit] Template parameters
| R | - | return type of the coroutine |
|---|---|---|
| Args | - | parameter types of the coroutine, including the implicit object parameter if the coroutine is a non-static member function |
[edit] Nested types
| Name | Definition |
|---|---|
| promise_type | R::promise_type if it is valid, or provided by program-defined specializations |
[edit] Possible implementation
namespace detail { template<class, class...> struct coroutine_traits_base {}; template<class R, class... Args> requires requires { typename R::promise_type; } struct coroutine_traits_base <R, Args...> { using promise_type = R::promise_type; }; } template<class R, class... Args> struct coroutine_traits : detail::coroutine_traits_base<R, Args...> {};
[edit] Notes
If the coroutine is a non-static member function, then the first type in Args... is the type of the implicit object parameter, and the rest are parameter types of the function (if any).
If std::coroutine_traits<R, Args...>::promise_type does not exist or is not a class type, the corresponding coroutine definition is ill-formed.
Users may define explicit or partial specializations of coroutine_traits dependent on program-defined types to avoid modification to return types.
[edit] Example
#include
#include
#include
#include
#include
#include
#include
// A program-defined type on which the coroutine_traits specializations below depend
struct as_coroutine {};
// Enable the use of std::future as a coroutine type
// by using a std::promise as the promise type.
template<typename T, typename... Args>
requires( &&
)
struct std::coroutine_traits<std::future, as_coroutine, Args...>
{
struct promise_type : std::promise
{
std::future get_return_object() noexcept
{
return this->get_future();
}
std::suspend_never initial_suspend() const noexcept { return {}; }
std::suspend_never final_suspend() const noexcept { return {}; }
void return_value(const T& value)
noexcept(std::is_nothrow_copy_constructible_v)
{
this->set_value(value);
}
void return_value(T&& value) noexcept(std::is_nothrow_move_constructible_v)
{
this->set_value(std::move(value));
}
void unhandled_exception() noexcept
{
this->set_exception(std::current_exception());
}
};
};
// Same for std::future.
template<typename... Args>
struct std::coroutine_traits<std::future, as_coroutine, Args...>
{
struct promise_type : std::promise
{
std::future get_return_object() noexcept
{
return this->get_future();
}
std::suspend_never initial_suspend() const noexcept { return {}; }
std::suspend_never final_suspend() const noexcept { return {}; }
void return_void() noexcept
{
this->set_value();
}
void unhandled_exception() noexcept
{
this->set_exception(std::current_exception());
}
};
};
// Allow co_await'ing std::future and std::future
// by naively spawning a new thread for each co_await.
template
auto operator co_await(std::future future) noexcept
requires(
)
{
struct awaiter : std::future
{
bool await_ready() const noexcept
{
using namespace std::chrono_literals;
return this->wait_for(0s) != std::future_status::timeout;
}
void await_suspend(std::coroutine_handle<> cont) const
{
std::thread([this, cont]
{
this->wait();
cont();
}).detach();
}
T await_resume() { return this->get(); }
};
return awaiter { std::move(future) };
}
// Utilize the infrastructure we have established.
std::future compute(as_coroutine)
{
int a = co_await std::async([] { return 6; });
int b = co_await std::async([] { return 7; });
co_return a * b;
}
std::future fail(as_coroutine)
{
throw std::runtime_error("bleah");
co_return;
}
int main()
{
std::cout << compute({}).get() << '\n';
try
{
fail({}).get();
}
catch (const std::runtime_error& e)
{
std::cout << "error: " << e.what() << '\n';
}
}
Output: