passenger 6.0.13 → 6.0.15

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/coro.hpp

@@ -2,8 +2,8 @@
 // experimental/coro.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2021 Klemens D. Morgenstern
-//                    (klemens dot morgenstern at gmx dot net)
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -12,13 +12,17 @@
 #ifndef BOOST_ASIO_EXPERIMENTAL_CORO_HPP
 #define BOOST_ASIO_EXPERIMENTAL_CORO_HPP
 
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/dispatch.hpp>
-#include <boost/asio/experimental/detail/coro_promise_allocator.hpp>
-#include <boost/asio/experimental/detail/partial_promise.hpp>
-#include <boost/asio/experimental/detail/coro_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/system/error_code.hpp>
+#include <boost/asio/experimental/coro_traits.hpp>
+#include <boost/asio/experimental/detail/coro_promise_allocator.hpp>
+#include <boost/asio/experimental/detail/partial_promise.hpp>
 #include <boost/asio/experimental/use_coro.hpp>
 #include <boost/asio/post.hpp>
 
@@ -27,215 +31,72 @@
 namespace boost {
 namespace asio {
 namespace experimental {
-
-template <typename Yield, typename Return, typename Executor>
-struct coro;
-
 namespace detail {
 
-template <typename Signature, typename Return, typename Executor>
-struct coro_promise;
-
-template <typename T>
-struct is_noexcept : std::false_type
-{
-};
-
-template <typename Return, typename... Args>
-struct is_noexcept<Return(Args...)> : std::false_type
-{
-};
-
-template <typename Return, typename... Args>
-struct is_noexcept<Return(Args...) noexcept> : std::true_type
-{
-};
-
-template <typename T>
-constexpr bool is_noexcept_v = is_noexcept<T>::value;
-
-template <typename T>
-struct coro_error;
-
-template <>
-struct coro_error<boost::system::error_code>
-{
-  static boost::system::error_code invalid()
-  {
-    return error::fault;
-  }
-
-  static boost::system::error_code cancelled()
-  {
-    return error::operation_aborted;
-  }
-
-  static boost::system::error_code interrupted()
-  {
-    return error::interrupted;
-  }
-
-  static boost::system::error_code done()
-  {
-    return error::broken_pipe;
-  }
-};
-
-template <>
-struct coro_error<std::exception_ptr>
-{
-  static std::exception_ptr invalid()
-  {
-    return std::make_exception_ptr(
-        boost::system::system_error(
-          coro_error<boost::system::error_code>::invalid()));
-  }
-
-  static std::exception_ptr cancelled()
-  {
-    return std::make_exception_ptr(
-        boost::system::system_error(
-          coro_error<boost::system::error_code>::cancelled()));
-  }
-
-  static std::exception_ptr interrupted()
-  {
-    return std::make_exception_ptr(
-        boost::system::system_error(
-          coro_error<boost::system::error_code>::interrupted()));
-  }
-
-  static std::exception_ptr done()
-  {
-    return std::make_exception_ptr(
-        boost::system::system_error(
-          coro_error<boost::system::error_code>::done()));
-  }
-};
-
-template <typename T, typename Coroutine, typename = void>
-struct coro_with_arg
-{
-  using coro_t = Coroutine;
-  T value;
-  coro_t& coro;
-
-  struct awaitable_t
-  {
-    T value;
-    coro_t& coro;
-
-    constexpr static bool await_ready() { return false; }
-
-    template <typename Y, typename R, typename E>
-    auto await_suspend(coroutine_handle<coro_promise<Y, R, E>> h)
-      -> coroutine_handle<>
-    {
-      auto& hp = h.promise();
-      if (hp.get_executor() == coro.get_executor())
-      {
-        coro.coro_->awaited_from = h;
-        coro.coro_->reset_error();
-        coro.coro_->input_ = std::move(value);
-        struct cancel_handler
-        {
-          cancel_handler(coro_t& coro) : coro(coro.coro_) {}
-
-          typename coro_t::promise_type* coro;
-
-          void operator()(cancellation_type ct)
-          {
-            coro->cancel.signal.emit(ct);
-          }
-        };
-
-        hp.cancel.state.slot().template emplace<cancel_handler>(coro);
-        return coro.coro_->get_handle();
-      } else
-      {
-        coro.coro_->awaited_from =
-          dispatch_coroutine(hp.get_executor(), [h]() mutable
-        { h.resume(); });
-        coro.coro_->reset_error();
-        coro.coro_->input_ = std::move(value);
-
-        struct cancel_handler
-        {
-          cancel_handler(E e, coro_t& coro) : e(e), coro(coro.coro_) {}
-
-          E e;
-          typename coro_t::promise_type* coro;
-
-          void operator()(cancellation_type ct)
-          {
-            boost::asio::dispatch(e,
-                [ct, p = coro]() mutable
-                {
-                  p->cancel.signal.emit(ct);
-                });
-          }
-        };
-
-        hp.cancel.state.slot().template emplace<cancel_handler>(
-            coro.get_executor(), coro);
-
-        return dispatch_coroutine(
-            hp.get_executor(), [h]() mutable { h.resume(); });
-      }
-
-    }
-
-    auto await_resume() -> typename coro_t::result_type
-    {
-      coro.coro_->cancel.state.slot().clear();
-      coro.coro_->rethrow_if();
-      return std::move(coro.coro_->result_);
-    }
-  };
-
-  template <typename CompletionToken>
-  auto async_resume(CompletionToken&& token) &&
-  {
-    return coro.async_resume(std::move(value),
-        std::forward<CompletionToken>(token));
-  }
-
-  auto operator co_await() &&
-  {
-    return awaitable_t{std::move(value), coro};
-  }
-};
+template <typename T, typename Coroutine>
+struct coro_with_arg;
 
 } // namespace detail
 
+/// The main type of a resumable coroutine.
+/**
+ * Template parameter @c Yield specifies type or signature used by co_yield,
+ * @c Return specifies the type used for co_return, and @c Executor specifies
+ * the underlying executor type.
+ */
 template <typename Yield = void, typename Return = void,
     typename Executor = any_io_executor>
 struct coro
 {
-  using traits = detail::coro_traits<Yield, Return, Executor>;
+  /// The traits of the coroutine. See boost::asio::experimental::coro_traits
+  /// for details.
+  using traits = coro_traits<Yield, Return, Executor>;
 
+  /// The value that can be passed into a symmetrical cororoutine. @c void if
+  /// asymmetrical.
   using input_type = typename traits::input_type;
+
+  /// The type that can be passed out through a co_yield.
   using yield_type = typename traits::yield_type;
+
+  /// The type that can be passed out through a co_return.
   using return_type = typename traits::return_type;
-  using error_type = typename traits::error_type;
+
+  /// The type received by a co_await or async_resume. Its a combination of
+  /// yield and return.
   using result_type = typename traits::result_type;
+
+  /// The signature used by the async_resume.
+  using signature_type = typename traits::signature_type;
+
+  /// Whether or not the coroutine is noexcept.
   constexpr static bool is_noexcept = traits::is_noexcept;
 
+  /// The error type of the coroutine. Void for noexcept
+  using error_type = typename traits::error_type;
+
+  /// Completion handler type used by async_resume.
+  using completion_handler = typename traits::completion_handler;
+
+  /// The internal promise-type of the coroutine.
   using promise_type = detail::coro_promise<Yield, Return, Executor>;
 
 #if !defined(GENERATING_DOCUMENTATION)
-  template <typename T, typename Coroutine, typename>
+  template <typename T, typename Coroutine>
   friend struct detail::coro_with_arg;
 #endif // !defined(GENERATING_DOCUMENTATION)
 
+  /// The executor type.
   using executor_type = Executor;
 
 #if !defined(GENERATING_DOCUMENTATION)
   friend struct detail::coro_promise<Yield, Return, Executor>;
 #endif // !defined(GENERATING_DOCUMENTATION)
 
+  /// The default constructor, gives an invalid coroutine.
   coro() = default;
 
+  /// Move constructor.
   coro(coro&& lhs) noexcept
     : coro_(std::exchange(lhs.coro_, nullptr))
   {
@@ -243,6 +104,7 @@ struct coro
 
   coro(const coro &) = delete;
 
+  /// Move assignment.
   coro& operator=(coro&& lhs) noexcept
   {
     std::swap(coro_, lhs.coro_);
@@ -251,6 +113,12 @@ struct coro
 
   coro& operator=(const coro&) = delete;
 
+  /// Destructor. Destroys the coroutine, if it holds a valid one.
+  /**
+   * @note This does not cancel an active coroutine. Destructing a resumable
+   * coroutine, i.e. one with a call to async_resume that has not completed, is
+   * undefined behaviour.
+   */
   ~coro()
   {
     if (coro_ != nullptr)
@@ -261,8 +129,7 @@ struct coro
 
         destroyer(const detail::coroutine_handle<promise_type>& handle)
           : handle(handle)
-        {
-        }
+        { }
 
         destroyer(destroyer&& lhs)
           : handle(std::exchange(lhs.handle, nullptr))
@@ -287,6 +154,7 @@ struct coro
     }
   }
 
+  /// Get the used executor.
   executor_type get_executor() const
   {
     if (coro_)
@@ -298,29 +166,61 @@ struct coro
       throw std::logic_error("Coroutine has no executor");
   }
 
+  /// Resume the coroutine.
+  /**
+   * @param token The completion token of the async resume.
+   *
+   * @attention Calling an invalid coroutine with a noexcept signature is
+   * undefined behaviour.
+   *
+   * @note This overload is only available for coroutines without an input
+   * value.
+   */
   template <typename CompletionToken>
     requires std::is_void_v<input_type>
-  auto async_resume(CompletionToken&& token)
+  auto async_resume(CompletionToken&& token) &
   {
     return async_initiate<CompletionToken,
         typename traits::completion_handler>(
           initiate_async_resume(this), token);
   }
 
-
+  /// Resume the coroutine.
+  /**
+   * @param token The completion token of the async resume.
+   *
+   * @attention Calling an invalid coroutine with a noexcept signature is
+   * undefined behaviour.
+   *
+   * @note This overload is only available for coroutines with an input value.
+   */
   template <typename CompletionToken, detail::convertible_to<input_type> T>
-  auto async_resume(T&& ip, CompletionToken&& token)
+  auto async_resume(T&& ip, CompletionToken&& token) &
   {
     return async_initiate<CompletionToken,
         typename traits::completion_handler>(
           initiate_async_resume(this), token, std::forward<T>(ip));
   }
 
+  /// Operator used for coroutines without input value.
   auto operator co_await() requires (std::is_void_v<input_type>)
   {
     return awaitable_t{*this};
   }
 
+  /// Operator used for coroutines with input value.
+  /**
+   * @param ip The input value
+   *
+   * @returns An awaitable handle.
+   *
+   * @code
+   * coro<void> push_values(coro<double(int)> c)
+   * {
+   *    std::optional<double> res = co_await c(42);
+   * }
+   * @endcode
+   */
   template <detail::convertible_to<input_type> T>
   auto operator()(T&& ip)
   {
@@ -328,6 +228,7 @@ struct coro
         std::forward<T>(ip), *this};
   }
 
+  /// Check whether the coroutine is open, i.e. can be resumed.
   bool is_open() const
   {
     if (coro_)
@@ -340,718 +241,25 @@ struct coro
       return false;
   }
 
+  /// Check whether the coroutine is open, i.e. can be resumed.
   explicit operator bool() const { return is_open(); }
 
-  void cancel(cancellation_type ct = cancellation_type::all)
-  {
-    if (is_open() && !coro_->cancel.state.cancelled())
-      boost::asio::dispatch(get_executor(),
-          [ct, coro = coro_] { coro->cancel.signal.emit(ct); });
-  }
-
 private:
-  struct awaitable_t
-  {
-    coro& coro_;
-
-    constexpr static bool await_ready() { return false; }
-
-    template <typename Y, typename R, typename E>
-    auto await_suspend(
-        detail::coroutine_handle<detail::coro_promise<Y, R, E>> h)
-      -> detail::coroutine_handle<>
-    {
-      auto& hp = h.promise();
-      if (hp.get_executor() == coro_.get_executor())
-      {
-        coro_.coro_->awaited_from = h;
-        coro_.coro_->reset_error();
-
-        struct cancel_handler
-        {
-          cancel_handler(coro& coro_) : coro_(coro_.coro_) {}
-
-          typename coro::promise_type* coro_;
-
-          void operator()(cancellation_type ct)
-          {
-            coro_->cancel.signal.emit(ct);
-          }
-        };
-
-        hp.cancel.state.slot().template emplace<cancel_handler>(coro_);
-        return coro_.coro_->get_handle();
-      }
-      else
-      {
-        coro_.coro_->awaited_from = detail::dispatch_coroutine(
-            hp.get_executor(), [h]() mutable { h.resume(); });
-        coro_.coro_->reset_error();
-
-        struct cancel_handler
-        {
-          cancel_handler(E e, coro& coro) : e(e), coro_(coro.coro_) {}
-
-          E e;
-          typename coro::promise_type* coro_;
-
-          void operator()(cancellation_type ct)
-          {
-            boost::asio::dispatch(e,
-                [ct, p = coro_]() mutable
-                {
-                  p->cancel.signal.emit(ct);
-                });
-          }
-        };
-
-        hp.cancel.state.slot().template emplace<cancel_handler>(
-            coro_.get_executor(), coro_);
-
-        return detail::dispatch_coroutine(
-            hp.get_executor(), [h]() mutable { h.resume(); });
-      }
-    }
-
-    auto await_resume() -> result_type
-    {
-      coro_.coro_->cancel.state.slot().clear();
-      coro_.coro_->rethrow_if();
-      if constexpr (!std::is_void_v<result_type>)
-        return std::move(coro_.coro_->result_);
-    }
-  };
-
-  class initiate_async_resume
-  {
-  public:
-    typedef Executor executor_type;
+  struct awaitable_t;
 
-    explicit initiate_async_resume(coro* self)
-      : self_(self)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename E, typename WaitHandler>
-    auto handle(E exec, WaitHandler&& handler,
-        std::true_type /* error is noexcept */,
-        std::true_type  /* result is void */) const //noexcept
-    {
-      return [self = self_,
-          h = std::forward<WaitHandler>(handler),
-          exec = std::move(exec)]() mutable
-      {
-        assert(self);
-        auto ch =
-          detail::coroutine_handle<promise_type>::from_promise(*self->coro_);
-        assert(ch && !ch.done());
-        assert(self->coro_->awaited_from == detail::noop_coroutine());
-
-        self->coro_->awaited_from =
-          post_coroutine(std::move(exec), std::move(h));
-        self->coro_->reset_error();
-        ch.resume();
-      };
-    }
-
-    template <typename E, typename WaitHandler>
-    requires (!std::is_void_v<result_type>)
-    auto handle(E exec, WaitHandler&& handler,
-        std::true_type /* error is noexcept */,
-        std::false_type  /* result is void */) const //noexcept
-    {
-      return [self = self_,
-          h = std::forward<WaitHandler>(handler),
-          exec = std::move(exec)]() mutable
-      {
-        assert(self);
-
-        auto ch =
-          detail::coroutine_handle<promise_type>::from_promise(*self->coro_);
-        assert(ch && !ch.done());
-        assert(self->coro_->awaited_from == detail::noop_coroutine());
-
-        self->coro_->awaited_from =
-          detail::post_coroutine(exec,
-              [self, h = std::move(h)]() mutable
-              {
-                std::move(h)(std::move(self->coro_->result_));
-              });
-        self->coro_->reset_error();
-        ch.resume();
-      };
-    }
-
-    template <typename E, typename WaitHandler>
-    auto handle(E exec, WaitHandler&& handler,
-        std::false_type /* error is noexcept */,
-        std::true_type  /* result is void */) const
-    {
-      return [self = self_,
-          h = std::forward<WaitHandler>(handler),
-          exec = std::move(exec)]() mutable
-      {
-        if (!self)
-        {
-          boost::asio::post(exec,
-              [h = std::move(h)]() mutable
-              {
-                h(detail::coro_error<error_type>::invalid());
-              });
-          return;
-        }
-
-        auto ch =
-          detail::coroutine_handle<promise_type>::from_promise(*self->coro_);
-        if (!ch)
-        {
-          boost::asio::post(exec,
-              [h = std::move(h)]() mutable
-              {
-                h(detail::coro_error<error_type>::invalid());
-              });
-        }
-        else if (ch.done())
-        {
-          boost::asio::post(exec,
-              [h = std::move(h)]() mutable
-              {
-                h(detail::coro_error<error_type>::done());
-              });
-        }
-        else
-        {
-          assert(self->coro_->awaited_from == detail::noop_coroutine());
-          self->coro_->awaited_from =
-            detail::post_coroutine(exec,
-                [self, h = std::move(h)]() mutable
-                {
-                  std::move(h)(std::move(self->coro_->error_));
-                });
-          self->coro_->reset_error();
-          ch.resume();
-        }
-      };
-    }
-
-    template <typename E, typename WaitHandler>
-    auto handle(E exec, WaitHandler&& handler,
-        std::false_type /* error is noexcept */,
-        std::false_type  /* result is void */) const
-    {
-      return [self = self_, h = std::forward<WaitHandler>(handler),
-          exec = std::move(exec)]() mutable
-      {
-        if (!self)
-        {
-          boost::asio::post(exec,
-              [h = std::move(h)]() mutable
-              {
-                h(detail::coro_error<error_type>::invalid(), result_type{});
-              });
-          return;
-        }
-
-        auto ch =
-          detail::coroutine_handle<promise_type>::from_promise(*self->coro_);
-        if (!ch)
-        {
-          boost::asio::post(exec,
-              [h = std::move(h)]() mutable
-              {
-                h(detail::coro_error<error_type>::invalid(), result_type{});
-              });
-        }
-        else if (ch.done())
-        {
-          boost::asio::post(exec,
-              [h = std::move(h)]() mutable
-              {
-                h(detail::coro_error<error_type>::done(), result_type{});
-              });
-        }
-        else
-        {
-          assert(self->coro_->awaited_from == detail::noop_coroutine());
-          self->coro_->awaited_from =
-              detail::post_coroutine(exec,
-                       [h = std::move(h), self]() mutable
-                       {
-                         std::move(h)(std::move(self->coro_->error_),
-                              std::move(self->coro_->result_));
-                       });
-          self->coro_->reset_error();
-          ch.resume();
-        }
-      };
-    }
-
-    struct cancel_handler
-    {
-      promise_type* coro;
-
-      cancel_handler(promise_type* coro) : coro(coro) {}
-
-      void operator()(cancellation_type ct)
-      {
-        boost::asio::dispatch(coro->get_executor(),
-            [ct, k = coro] { k->cancel.signal.emit(ct); });
-      }
-    };
-
-    template <typename WaitHandler>
-    void operator()(WaitHandler&& handler) const
-    {
-      const auto exec =
-        boost::asio::prefer(
-            get_associated_executor(handler, get_executor()),
-            execution::outstanding_work.tracked);
-
-      using cancel_t = decltype(self_->coro_->cancel);
-      self_->coro_->cancel.~cancel_t();
-      new(&self_->coro_->cancel) cancel_t();
-
-      auto cancel = get_associated_cancellation_slot(handler);
-      if (cancel.is_connected())
-        cancel.template emplace<cancel_handler>(self_->coro_);
-
-      boost::asio::dispatch(get_executor(),
-           handle(exec, std::forward<WaitHandler>(handler),
-             std::integral_constant<bool, is_noexcept>{},
-            std::is_void<result_type>{}));
-    }
-
-    template <typename WaitHandler, typename Input>
-    void operator()(WaitHandler&& handler, Input&& input) const
-    {
-      const auto exec =
-        boost::asio::prefer(
-            get_associated_executor(handler, get_executor()),
-            execution::outstanding_work.tracked);
-      auto cancel = get_associated_cancellation_slot(handler);
-
-      using cancel_t = decltype(self_->coro_->cancel);
-      self_->coro_->cancel.~cancel_t();
-      new(&self_->coro_->cancel) cancel_t();
-
-      if (cancel.is_connected())
-        cancel.template emplace<cancel_handler>(self_->coro_);
-
-      boost::asio::dispatch(get_executor(),
-          [h = handle(exec, std::forward<WaitHandler>(handler),
-            std::integral_constant<bool, is_noexcept>{},
-            std::is_void<result_type>{}),
-             in = std::forward<Input>(input), self = self_]() mutable
-          {
-            self->coro_->input_ = std::move(in);
-            std::move(h)();
-          });
-    }
-
-  private:
-    coro* self_;
-  };
+  struct initiate_async_resume;
 
   explicit coro(promise_type* const cr) : coro_(cr) {}
 
   promise_type* coro_{nullptr};
 };
 
-namespace detail {
-
-template <bool IsNoexcept>
-struct coro_promise_error;
-
-template <>
-struct coro_promise_error<false>
-{
-  std::exception_ptr error_;
-
-  void reset_error() { error_ = std::exception_ptr{}; }
-
-  void unhandled_exception() { error_ = std::current_exception(); }
-
-  void rethrow_if()
-  {
-    if (error_)
-      std::rethrow_exception(error_);
-  }
-};
-
-template <>
-struct coro_promise_error<true>
-{
-  void reset_error() {}
-
-  void unhandled_exception() noexcept { throw; }
-
-  void rethrow_if() {}
-};
-
-template <typename T = void>
-struct yield_input
-{
-  T& value;
-  coroutine_handle<> awaited_from{noop_coroutine()};
-
-  bool await_ready() const noexcept
-  {
-    return false;
-  }
-
-  auto await_suspend(coroutine_handle<>) noexcept
-  {
-    return std::exchange(awaited_from, noop_coroutine());
-  }
-
-  T await_resume() const noexcept { return std::move(value); }
-};
-
-template <>
-struct yield_input<void>
-{
-  coroutine_handle<> awaited_from{noop_coroutine()};
-
-  bool await_ready() const noexcept
-  {
-    return false;
-  }
-
-  auto await_suspend(coroutine_handle<>) noexcept
-  {
-    return std::exchange(awaited_from, noop_coroutine());
-  }
-
-  constexpr void await_resume() const noexcept {}
-};
-
-struct coro_awaited_from
-{
-  coroutine_handle<> awaited_from{noop_coroutine()};
-
-  auto final_suspend() noexcept
-  {
-    struct suspendor
-    {
-      coroutine_handle<> awaited_from;
-
-      constexpr static bool await_ready() noexcept { return false; }
-
-      auto await_suspend(coroutine_handle<>) noexcept
-      {
-        return std::exchange(awaited_from, noop_coroutine());
-      }
-
-      constexpr static void await_resume() noexcept {}
-    };
-
-    return suspendor{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  ~coro_awaited_from()
-  {
-    awaited_from.resume();
-  }//must be on the right executor
-};
-
-template <typename Yield, typename Input, typename Return>
-struct coro_promise_exchange : coro_awaited_from
-{
-  using result_type = coro_result_t<Yield, Return>;
-
-  result_type result_;
-  Input input_;
-
-  auto yield_value(Yield&& y)
-  {
-    result_ = std::move(y);
-    return yield_input<Input>{std::move(input_),
-      std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  auto yield_value(const Yield& y)
-  {
-    result_ = y;
-    return yield_input<Input>{std::move(input_),
-      std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  void return_value(const Return& r) { result_ = r; }
-
-  void return_value(Return&& r) { result_ = std::move(r); }
-};
-
-template <typename YieldReturn>
-struct coro_promise_exchange<YieldReturn, void, YieldReturn> : coro_awaited_from
-{
-  using result_type = coro_result_t<YieldReturn, YieldReturn>;
-
-  result_type result_;
-
-  auto yield_value(const YieldReturn& y)
-  {
-    result_ = y;
-    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  auto yield_value(YieldReturn&& y)
-  {
-    result_ = std::move(y);
-    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  void return_value(const YieldReturn& r) { result_ = r; }
-
-  void return_value(YieldReturn&& r) { result_ = std::move(r); }
-};
-
-template <typename Yield, typename Return>
-struct coro_promise_exchange<Yield, void, Return> : coro_awaited_from
-{
-  using result_type = coro_result_t<Yield, Return>;
-
-  result_type result_;
-
-  auto yield_value(const Yield& y)
-  {
-    result_.template emplace<0>(y);
-    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  auto yield_value(Yield&& y)
-  {
-    result_.template emplace<0>(std::move(y));
-    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  void return_value(const Return& r)
-  { result_.template emplace<1>(r); }
-
-  void return_value(Return&& r)
-  { result_.template emplace<1>(std::move(r)); }
-};
-
-template <typename Yield, typename Input>
-struct coro_promise_exchange<Yield, Input, void> : coro_awaited_from
-{
-  using result_type = coro_result_t<Yield, void>;
-
-  result_type result_;
-  Input input_;
-
-  auto yield_value(Yield&& y)
-  {
-    result_ = std::move(y);
-    return yield_input<Input>{input_,
-      std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  auto yield_value(const Yield& y)
-  {
-    result_ = y;
-    return yield_input<Input>{input_,
-      std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  void return_void() { result_.reset(); }
-};
-
-template <typename Return>
-struct coro_promise_exchange<void, void, Return> : coro_awaited_from
-{
-  using result_type = coro_result_t<void, Return>;
-
-  result_type result_;
-
-  void yield_value();
-
-  void return_value(const Return& r) { result_ = r; }
-
-  void return_value(Return&& r) { result_ = std::move(r); }
-};
-
-
-template <>
-struct coro_promise_exchange<void, void, void> : coro_awaited_from
-{
-  void return_void() {}
-
-  void yield_value();
-};
-
-template <typename Yield>
-struct coro_promise_exchange<Yield, void, void> : coro_awaited_from
-{
-  using result_type = coro_result_t<Yield, void>;
-
-  result_type result_;
-
-  auto yield_value(const Yield& y)
-  {
-    result_ = y;
-    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  auto yield_value(Yield&& y)
-  {
-    result_ = std::move(y);
-    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  void return_void() { result_.reset(); }
-};
-
-template <typename Yield, typename Return, typename Executor>
-struct coro_promise final :
-  coro_promise_allocator<coro<Yield, Return, Executor>>,
-  coro_promise_error<coro_traits<Yield, Return, Executor>::is_noexcept>,
-  coro_promise_exchange<
-      typename coro_traits<Yield, Return, Executor>::yield_type,
-      typename coro_traits<Yield, Return, Executor>::input_type,
-      typename coro_traits<Yield, Return, Executor>::return_type>
-{
-  using coro_type = coro<Yield, Return, Executor>;
-
-  auto handle()
-  { return coroutine_handle<coro_promise>::from_promise(this); }
-
-  using executor_type = Executor;
-
-  executor_type executor_;
-  struct cancel_pair
-  {
-    cancellation_signal signal;
-    boost::asio::cancellation_state state{signal.slot()};
-
-  };
-  cancel_pair cancel;
-
-  using allocator_type =
-    typename std::allocator_traits<associated_allocator_t < Executor>>::
-  template rebind_alloc<std::byte>;
-  using traits = coro_traits<Yield, Return, Executor>;
-
-  using input_type = typename traits::input_type;
-  using yield_type = typename traits::yield_type;
-  using return_type = typename traits::return_type;
-  using error_type = typename traits::error_type;
-  using result_type = typename traits::result_type;
-  constexpr static bool is_noexcept = traits::is_noexcept;
-
-  auto get_executor() const -> Executor { return executor_; }
-
-  auto get_handle()
-  {
-    return coroutine_handle<coro_promise>::from_promise(*this);
-  }
-
-  template <typename... Args>
-  coro_promise(Executor executor, Args &&...) noexcept
-    : executor_(std::move(executor))
-  {
-  }
-
-  template <execution_context Context, typename... Args>
-  coro_promise(Context&& ctx, Args&&...) noexcept
-    : executor_(ctx.get_executor())
-  {
-  }
-
-  auto get_return_object()
-  {
-    return coro<Yield, Return, Executor>{this};
-  }
-
-  auto initial_suspend() noexcept
-  {
-    return suspend_always{};
-  }
-
-  using coro_promise_exchange<
-      typename coro_traits<Yield, Return, Executor>::yield_type,
-      typename coro_traits<Yield, Return, Executor>::input_type,
-      typename coro_traits<Yield, Return, Executor>::return_type>::yield_value;
-
-  auto await_transform(this_coro::executor_t) const
-  {
-    struct exec_helper
-    {
-      const executor_type& value;
-
-      constexpr static bool await_ready() noexcept { return true; }
-
-      constexpr static void await_suspend(coroutine_handle<>) noexcept {}
-
-      executor_type await_resume() const noexcept { return value; }
-    };
-
-    return exec_helper{executor_};
-  }
-
-  auto await_transform(this_coro::cancellation_state_t) const
-  {
-    struct exec_helper
-    {
-      const boost::asio::cancellation_state& value;
-
-      constexpr static bool await_ready() noexcept { return true; }
-
-      constexpr static void await_suspend(coroutine_handle<>) noexcept {}
-
-      const boost::asio::cancellation_state& await_resume() const noexcept
-      {
-        return value;
-      }
-    };
-
-    return exec_helper{cancel.state};
-  }
-
-  template <typename Yield_, typename Return_, typename Executor_>
-  auto await_transform(coro<Yield_, Return_, Executor_>& kr) -> decltype(auto)
-  {
-    return kr;
-  }
-
-  template <typename Yield_, typename Return_, typename Executor_>
-  auto await_transform(coro<Yield_, Return_, Executor_>&& kr)
-  {
-    return std::move(kr);
-  }
-
-  template <typename T_, typename Coroutine>
-  auto await_transform(coro_with_arg<T_, Coroutine>&& kr) -> decltype(auto)
-  {
-    return std::move(kr);
-  }
-
-  template <typename T_>
-    requires requires(T_ t) {{ t.async_wait(use_coro) }; }
-  auto await_transform(T_ &t) -> decltype(auto)
-  {
-    return await_transform(t.async_wait(use_coro));
-  }
-
-  template <typename... Ts>
-  auto await_transform(coro_init_handler<Executor, Ts...>&& kr) const
-  {
-    if constexpr (is_noexcept)
-      return std::move(kr).as_noexcept(cancel.state.slot());
-    else
-      return std::move(kr).as_throwing(cancel.state.slot());
-  }
-};
-
-} // namespace detail
 } // namespace experimental
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
+#include <boost/asio/experimental/impl/coro.hpp>
+
 #endif // BOOST_ASIO_EXPERIMENTAL_CORO_HPP