diff --git a/doc/overview/spawn.qbk b/doc/overview/spawn.qbk
index b1615b97..0c360694 100644
--- a/doc/overview/spawn.qbk
+++ b/doc/overview/spawn.qbk
@@ -12,7 +12,7 @@ running stackful coroutines. It is based on the Boost.Coroutine library. The
 `spawn()` function enables programs to implement asynchronous logic in a
 synchronous manner, as shown in the following example:
 
-  boost::asio::spawn(my_strand, do_echo);
+  boost::asio::spawn(my_strand, do_echo, boost::asio::detached);
 
   // ...
 
@@ -37,10 +37,7 @@ synchronous manner, as shown in the following example:
     }
   }
 
-The first argument to `spawn()` may be a
-[link boost_asio.reference.io_context__strand `strand`],
-[link boost_asio.reference.io_context `io_context`], or a
-[link boost_asio.reference.Handler completion handler].
+The first argument to `spawn()` may be an executor or execution context.
 This argument determines the context in which the coroutine is permitted to
 execute. For example, a server's per-client object may consist of multiple
 coroutines; they should all run on the same `strand` so that no explicit
@@ -85,10 +82,10 @@ exception, associate the output variable with the `yield_context` as follows:
     my_socket.async_read_some(
       boost::asio::buffer(data), yield[ec]);
   
-[*Note:] if `spawn()` is used with a custom completion handler of type
-`Handler`, the function object signature is actually:
+[*Note:] if `spawn()` is used with a specified executor of type `Executor`, the
+function object signature is actually:
   
-  void coroutine(boost::asio::basic_yield_context<Handler> yield);
+  void coroutine(boost::asio::basic_yield_context<Executor> yield);
 
 [heading See Also]
 
diff --git a/doc/reference.xsl b/doc/reference.xsl
index 48f80e41..0c51d393 100644
--- a/doc/reference.xsl
+++ b/doc/reference.xsl
@@ -1610,6 +1610,9 @@
 <xsl:text>
       </xsl:text><xsl:value-of select="type"/><xsl:text> </xsl:text>
       <xsl:choose>
+        <xsl:when test="declname = 'A'">
+          <xsl:value-of select="declname"/>
+        </xsl:when>
         <xsl:when test="declname = 'Allocator'">
           <xsl:value-of select="declname"/>
         </xsl:when>
@@ -1712,6 +1715,9 @@
         <xsl:when test="declname = 'Head'">
           <xsl:value-of select="declname"/>
         </xsl:when>
+        <xsl:when test="declname = 'I'">
+          <xsl:value-of select="declname"/>
+        </xsl:when>
         <xsl:when test="declname = 'IoObjectService1'">
           <xsl:value-of select="concat('``[link boost_asio.reference.IoObjectService ', declname, ']``')"/>
         </xsl:when>
@@ -1853,6 +1859,9 @@
         <xsl:when test="declname = 'SocketService1' or declname = 'SocketService2'">
           <xsl:value-of select="concat('``[link boost_asio.reference.SocketService ', declname, ']``')"/>
         </xsl:when>
+        <xsl:when test="declname = 'StackAllocator'">
+          <xsl:value-of select="declname"/>
+        </xsl:when>
         <xsl:when test="declname = 'Stream'">
           <xsl:value-of select="declname"/>
         </xsl:when>
diff --git a/example/cpp03/spawn/echo_server.cpp b/example/cpp03/spawn/echo_server.cpp
index ba634105..913cbecc 100644
--- a/example/cpp03/spawn/echo_server.cpp
+++ b/example/cpp03/spawn/echo_server.cpp
@@ -8,6 +8,7 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
+#include <boost/asio/detached.hpp>
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/asio/spawn.hpp>
@@ -39,10 +40,12 @@ public:
   {
     boost::asio::spawn(strand_,
         boost::bind(&session::echo,
-          shared_from_this(), boost::placeholders::_1));
+          shared_from_this(), boost::placeholders::_1),
+        boost::asio::detached_t());
     boost::asio::spawn(strand_,
         boost::bind(&session::timeout,
-          shared_from_this(), boost::placeholders::_1));
+          shared_from_this(), boost::placeholders::_1),
+        boost::asio::detached_t());
   }
 
 private:
@@ -108,8 +111,9 @@ int main(int argc, char* argv[])
     boost::asio::io_context io_context;
 
     boost::asio::spawn(io_context,
-        boost::bind(do_accept,
-          boost::ref(io_context), atoi(argv[1]), boost::placeholders::_1));
+        boost::bind(do_accept, boost::ref(io_context),
+          atoi(argv[1]), boost::placeholders::_1),
+        boost::asio::detached_t());
 
     io_context.run();
   }
diff --git a/example/cpp03/spawn/parallel_grep.cpp b/example/cpp03/spawn/parallel_grep.cpp
index 60ee7885..7c4b764e 100644
--- a/example/cpp03/spawn/parallel_grep.cpp
+++ b/example/cpp03/spawn/parallel_grep.cpp
@@ -8,6 +8,7 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
+#include <boost/asio/detached.hpp>
 #include <boost/asio/dispatch.hpp>
 #include <boost/asio/post.hpp>
 #include <boost/asio/spawn.hpp>
@@ -19,6 +20,7 @@
 #include <iostream>
 #include <string>
 
+using boost::asio::detached_t;
 using boost::asio::dispatch;
 using boost::asio::spawn;
 using boost::asio::strand;
@@ -74,8 +76,10 @@ int main(int argc, char* argv[])
     for (int argn = 2; argn < argc; ++argn)
     {
       std::string input_file = argv[argn];
-      spawn(pool, boost::bind(&search_file, search_string,
-            input_file, output_strand, boost::placeholders::_1));
+      spawn(pool,
+          boost::bind(&search_file, search_string,
+            input_file, output_strand, boost::placeholders::_1),
+          detached_t());
     }
 
     // Join the thread pool to wait for all the spawned tasks to complete.
diff --git a/example/cpp11/spawn/echo_server.cpp b/example/cpp11/spawn/echo_server.cpp
index 7e1d4404..b2eff11e 100644
--- a/example/cpp11/spawn/echo_server.cpp
+++ b/example/cpp11/spawn/echo_server.cpp
@@ -8,6 +8,7 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
+#include <boost/asio/detached.hpp>
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/asio/spawn.hpp>
@@ -49,7 +50,7 @@ public:
             socket_.close();
             timer_.cancel();
           }
-        });
+        }, boost::asio::detached);
 
     boost::asio::spawn(strand_,
         [this, self](boost::asio::yield_context yield)
@@ -61,7 +62,7 @@ public:
             if (timer_.expires_from_now() <= std::chrono::seconds(0))
               socket_.close();
           }
-        });
+        }, boost::asio::detached);
   }
 
 private:
@@ -98,7 +99,7 @@ int main(int argc, char* argv[])
               std::make_shared<session>(io_context, std::move(socket))->go();
             }
           }
-        });
+        }, boost::asio::detached);
 
     io_context.run();
   }
diff --git a/example/cpp11/spawn/parallel_grep.cpp b/example/cpp11/spawn/parallel_grep.cpp
index 819b133e..d2ab2256 100644
--- a/example/cpp11/spawn/parallel_grep.cpp
+++ b/example/cpp11/spawn/parallel_grep.cpp
@@ -8,6 +8,7 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
+#include <boost/asio/detached.hpp>
 #include <boost/asio/dispatch.hpp>
 #include <boost/asio/post.hpp>
 #include <boost/asio/spawn.hpp>
@@ -17,6 +18,7 @@
 #include <iostream>
 #include <string>
 
+using boost::asio::detached;
 using boost::asio::dispatch;
 using boost::asio::spawn;
 using boost::asio::strand;
@@ -69,7 +71,7 @@ int main(int argc, char* argv[])
             if (++line_num % 10 == 0)
               post(yield);
           }
-        });
+        }, detached);
     }
 
     // Join the thread pool to wait for all the spawned tasks to complete.
diff --git a/include/boost/asio/detail/config.hpp b/include/boost/asio/detail/config.hpp
index 77386332..473b6d3b 100644
--- a/include/boost/asio/detail/config.hpp
+++ b/include/boost/asio/detail/config.hpp
@@ -844,6 +844,35 @@
 # endif // !defined(BOOST_ASIO_DISABLE_BOOST_DATE_TIME)
 #endif // !defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
 
+// Boost support for the Coroutine library.
+#if !defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+# if !defined(BOOST_ASIO_DISABLE_BOOST_COROUTINE)
+#  define BOOST_ASIO_HAS_BOOST_COROUTINE 1
+# endif // !defined(BOOST_ASIO_DISABLE_BOOST_COROUTINE)
+#endif // !defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+
+// Boost support for the Context library's fibers.
+#if !defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
+# if !defined(BOOST_ASIO_DISABLE_BOOST_CONTEXT_FIBER)
+#  if defined(__clang__)
+#   if (__cplusplus >= 201103)
+#    define BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER 1
+#   endif // (__cplusplus >= 201103)
+#  elif defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
+#    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER 1
+#    endif // (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSVC_LANG >= 201103)
+#    define BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER 1
+#   endif // (_MSC_LANG >= 201103)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_BOOST_CONTEXT_FIBER)
+#endif // !defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
+
 // Standard library support for addressof.
 #if !defined(BOOST_ASIO_HAS_STD_ADDRESSOF)
 # if !defined(BOOST_ASIO_DISABLE_STD_ADDRESSOF)
diff --git a/include/boost/asio/detail/exception.hpp b/include/boost/asio/detail/exception.hpp
new file mode 100644
index 00000000..dfb45151
--- /dev/null
+++ b/include/boost/asio/detail/exception.hpp
@@ -0,0 +1,42 @@
+//
+// detail/exception.hpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// 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)
+//
+
+#ifndef BOOST_ASIO_DETAIL_EXCEPTION_HPP
+#define BOOST_ASIO_DETAIL_EXCEPTION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_STD_EXCEPTION)
+# include <exception>
+#else // defined(BOOST_ASIO_HAS_STD_EXCEPTION)
+# include <boost/exception_ptr.hpp>
+#endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION)
+
+namespace boost {
+namespace asio {
+
+#if defined(BOOST_ASIO_HAS_STD_EXCEPTION)
+using std::exception_ptr;
+using std::current_exception;
+using std::rethrow_exception;
+#else // defined(BOOST_ASIO_HAS_STD_EXCEPTION)
+using boost::exception_ptr;
+using boost::current_exception;
+using boost::rethrow_exception;
+#endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION)
+
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_DETAIL_EXCEPTION_HPP
diff --git a/include/boost/asio/impl/spawn.hpp b/include/boost/asio/impl/spawn.hpp
index 43778cf8..29ed1c61 100644
--- a/include/boost/asio/impl/spawn.hpp
+++ b/include/boost/asio/impl/spawn.hpp
@@ -17,6 +17,7 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associated_cancellation_slot.hpp>
 #include <boost/asio/associated_executor.hpp>
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/bind_executor.hpp>
@@ -27,385 +28,1334 @@
 #include <boost/asio/detail/memory.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
 #include <boost/system/system_error.hpp>
 
+#if defined(BOOST_ASIO_HAS_STD_TUPLE)
+# include <tuple>
+#endif // defined(BOOST_ASIO_HAS_STD_TUPLE)
+
+#if defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
+# include <boost/context/fiber.hpp>
+#endif // defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-  template <typename Handler, typename T>
-  class coro_handler
+#if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+
+// Spawned thread implementation using Boost.Coroutine.
+class spawned_coroutine_thread : public spawned_thread_base
+{
+public:
+#if defined(BOOST_COROUTINES_UNIDIRECT) || defined(BOOST_COROUTINES_V2)
+  typedef boost::coroutines::pull_coroutine<void> callee_type;
+  typedef boost::coroutines::push_coroutine<void> caller_type;
+#else
+  typedef boost::coroutines::coroutine<void()> callee_type;
+  typedef boost::coroutines::coroutine<void()> caller_type;
+#endif
+
+  spawned_coroutine_thread(caller_type& caller)
+    : caller_(caller),
+      on_suspend_fn_(0),
+      on_suspend_arg_(0)
+  {
+  }
+
+  template <typename F>
+  static spawned_thread_base* spawn(BOOST_ASIO_MOVE_ARG(F) f,
+      const boost::coroutines::attributes& attributes,
+      cancellation_slot parent_cancel_slot = cancellation_slot(),
+      cancellation_state cancel_state = cancellation_state())
+  {
+    spawned_coroutine_thread* spawned_thread = 0;
+    callee_type callee(entry_point<typename decay<F>::type>(
+          BOOST_ASIO_MOVE_CAST(F)(f), &spawned_thread), attributes);
+    spawned_thread->callee_.swap(callee);
+    spawned_thread->parent_cancellation_slot_ = parent_cancel_slot;
+    spawned_thread->cancellation_state_ = cancel_state;
+    return spawned_thread;
+  }
+
+  template <typename F>
+  static spawned_thread_base* spawn(BOOST_ASIO_MOVE_ARG(F) f,
+      cancellation_slot parent_cancel_slot = cancellation_slot(),
+      cancellation_state cancel_state = cancellation_state())
+  {
+    return spawn(BOOST_ASIO_MOVE_CAST(F)(f), boost::coroutines::attributes(),
+        parent_cancel_slot, cancel_state);
+  }
+
+  void resume()
+  {
+    callee_();
+    if (on_suspend_fn_)
+    {
+      void (*fn)(void*) = on_suspend_fn_;
+      void* arg = on_suspend_arg_;
+      on_suspend_fn_ = 0;
+      fn(arg);
+    }
+  }
+
+  void suspend_with(void (*fn)(void*), void* arg)
+  {
+    if (throw_if_cancelled_)
+      if (!!cancellation_state_.cancelled())
+        throw_error(boost::asio::error::operation_aborted, "yield");
+    has_context_switched_ = true;
+    on_suspend_fn_ = fn;
+    on_suspend_arg_ = arg;
+    caller_();
+  }
+
+  void destroy()
+  {
+    callee_type callee;
+    callee.swap(callee_);
+  }
+
+private:
+  template <typename Function>
+  class entry_point
   {
   public:
-    coro_handler(basic_yield_context<Handler> ctx)
-      : coro_(ctx.coro_.lock()),
-        ca_(ctx.ca_),
-        handler_(ctx.handler_),
-        ready_(0),
-        ec_(ctx.ec_),
-        value_(0)
+    template <typename F>
+    entry_point(BOOST_ASIO_MOVE_ARG(F) f,
+        spawned_coroutine_thread** spawned_thread_out)
+      : function_(BOOST_ASIO_MOVE_CAST(F)(f)),
+        spawned_thread_out_(spawned_thread_out)
     {
     }
 
-    void operator()(T value)
+    void operator()(caller_type& caller)
     {
-      *ec_ = boost::system::error_code();
-      *value_ = BOOST_ASIO_MOVE_CAST(T)(value);
-      if (--*ready_ == 0)
-        (*coro_)();
-    }
-
-    void operator()(boost::system::error_code ec, T value)
-    {
-      *ec_ = ec;
-      *value_ = BOOST_ASIO_MOVE_CAST(T)(value);
-      if (--*ready_ == 0)
-        (*coro_)();
-    }
-
-  //private:
-    shared_ptr<typename basic_yield_context<Handler>::callee_type> coro_;
-    typename basic_yield_context<Handler>::caller_type& ca_;
-    Handler handler_;
-    atomic_count* ready_;
-    boost::system::error_code* ec_;
-    T* value_;
-  };
-
-  template <typename Handler>
-  class coro_handler<Handler, void>
-  {
-  public:
-    coro_handler(basic_yield_context<Handler> ctx)
-      : coro_(ctx.coro_.lock()),
-        ca_(ctx.ca_),
-        handler_(ctx.handler_),
-        ready_(0),
-        ec_(ctx.ec_)
-    {
-    }
-
-    void operator()()
-    {
-      *ec_ = boost::system::error_code();
-      if (--*ready_ == 0)
-        (*coro_)();
-    }
-
-    void operator()(boost::system::error_code ec)
-    {
-      *ec_ = ec;
-      if (--*ready_ == 0)
-        (*coro_)();
-    }
-
-  //private:
-    shared_ptr<typename basic_yield_context<Handler>::callee_type> coro_;
-    typename basic_yield_context<Handler>::caller_type& ca_;
-    Handler handler_;
-    atomic_count* ready_;
-    boost::system::error_code* ec_;
-  };
-
-  template <typename Handler, typename T>
-  inline asio_handler_allocate_is_deprecated
-  asio_handler_allocate(std::size_t size,
-      coro_handler<Handler, T>* this_handler)
-  {
-#if defined(BOOST_ASIO_NO_DEPRECATED)
-    boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
-    return asio_handler_allocate_is_no_longer_used();
-#else // defined(BOOST_ASIO_NO_DEPRECATED)
-    return boost_asio_handler_alloc_helpers::allocate(
-        size, this_handler->handler_);
-#endif // defined(BOOST_ASIO_NO_DEPRECATED)
-  }
-
-  template <typename Handler, typename T>
-  inline asio_handler_deallocate_is_deprecated
-  asio_handler_deallocate(void* pointer, std::size_t size,
-      coro_handler<Handler, T>* this_handler)
-  {
-    boost_asio_handler_alloc_helpers::deallocate(
-        pointer, size, this_handler->handler_);
-#if defined(BOOST_ASIO_NO_DEPRECATED)
-    return asio_handler_deallocate_is_no_longer_used();
-#endif // defined(BOOST_ASIO_NO_DEPRECATED)
-  }
-
-  template <typename Handler, typename T>
-  inline bool asio_handler_is_continuation(coro_handler<Handler, T>*)
-  {
-    return true;
-  }
-
-  template <typename Function, typename Handler, typename T>
-  inline asio_handler_invoke_is_deprecated
-  asio_handler_invoke(Function& function,
-      coro_handler<Handler, T>* this_handler)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->handler_);
-#if defined(BOOST_ASIO_NO_DEPRECATED)
-    return asio_handler_invoke_is_no_longer_used();
-#endif // defined(BOOST_ASIO_NO_DEPRECATED)
-  }
-
-  template <typename Function, typename Handler, typename T>
-  inline asio_handler_invoke_is_deprecated
-  asio_handler_invoke(const Function& function,
-      coro_handler<Handler, T>* this_handler)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->handler_);
-#if defined(BOOST_ASIO_NO_DEPRECATED)
-    return asio_handler_invoke_is_no_longer_used();
-#endif // defined(BOOST_ASIO_NO_DEPRECATED)
-  }
-
-  template <typename Handler, typename T>
-  class coro_async_result
-  {
-  public:
-    typedef coro_handler<Handler, T> completion_handler_type;
-    typedef T return_type;
-
-    explicit coro_async_result(completion_handler_type& h)
-      : handler_(h),
-        ca_(h.ca_),
-        ready_(2)
-    {
-      h.ready_ = &ready_;
-      out_ec_ = h.ec_;
-      if (!out_ec_) h.ec_ = &ec_;
-      h.value_ = &value_;
-    }
-
-    return_type get()
-    {
-      // Must not hold shared_ptr to coro while suspended.
-      handler_.coro_.reset();
-
-      if (--ready_ != 0)
-        ca_();
-      if (!out_ec_ && ec_) throw boost::system::system_error(ec_);
-      return BOOST_ASIO_MOVE_CAST(return_type)(value_);
+      Function function(BOOST_ASIO_MOVE_CAST(Function)(function_));
+      spawned_coroutine_thread spawned_thread(caller);
+      *spawned_thread_out_ = &spawned_thread;
+      spawned_thread_out_ = 0;
+      spawned_thread.suspend();
+      function(&spawned_thread);
+      spawned_thread.suspend();
     }
 
   private:
-    completion_handler_type& handler_;
-    typename basic_yield_context<Handler>::caller_type& ca_;
-    atomic_count ready_;
-    boost::system::error_code* out_ec_;
-    boost::system::error_code ec_;
-    return_type value_;
+    Function function_;
+    spawned_coroutine_thread** spawned_thread_out_;
   };
 
-  template <typename Handler>
-  class coro_async_result<Handler, void>
+  caller_type& caller_;
+  callee_type callee_;
+  void (*on_suspend_fn_)(void*);
+  void* on_suspend_arg_;
+};
+
+#endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+
+#if defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
+
+// Spawned thread implementation using Boost.Context's fiber.
+class spawned_fiber_thread : public spawned_thread_base
+{
+public:
+  typedef boost::context::fiber fiber_type;
+
+  spawned_fiber_thread(BOOST_ASIO_MOVE_ARG(fiber_type) caller)
+    : caller_(BOOST_ASIO_MOVE_CAST(fiber_type)(caller)),
+      on_suspend_fn_(0),
+      on_suspend_arg_(0)
+  {
+  }
+
+  template <typename StackAllocator, typename F>
+  static spawned_thread_base* spawn(allocator_arg_t,
+      BOOST_ASIO_MOVE_ARG(StackAllocator) stack_allocator,
+      BOOST_ASIO_MOVE_ARG(F) f,
+      cancellation_slot parent_cancel_slot = cancellation_slot(),
+      cancellation_state cancel_state = cancellation_state())
+  {
+    spawned_fiber_thread* spawned_thread = 0;
+    fiber_type callee(allocator_arg_t(),
+        BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
+        entry_point<typename decay<F>::type>(
+          BOOST_ASIO_MOVE_CAST(F)(f), &spawned_thread));
+    callee = BOOST_ASIO_MOVE_CAST(fiber_type)(callee).resume();
+    spawned_thread->callee_ = BOOST_ASIO_MOVE_CAST(fiber_type)(callee);
+    spawned_thread->parent_cancellation_slot_ = parent_cancel_slot;
+    spawned_thread->cancellation_state_ = cancel_state;
+    return spawned_thread;
+  }
+
+  template <typename F>
+  static spawned_thread_base* spawn(BOOST_ASIO_MOVE_ARG(F) f,
+      cancellation_slot parent_cancel_slot = cancellation_slot(),
+      cancellation_state cancel_state = cancellation_state())
+  {
+    return spawn(allocator_arg_t(), boost::context::fixedsize_stack(),
+        BOOST_ASIO_MOVE_CAST(F)(f), parent_cancel_slot, cancel_state);
+  }
+
+  void resume()
+  {
+    callee_ = BOOST_ASIO_MOVE_CAST(fiber_type)(callee_).resume();
+    if (on_suspend_fn_)
+    {
+      void (*fn)(void*) = on_suspend_fn_;
+      void* arg = on_suspend_arg_;
+      on_suspend_fn_ = 0;
+      fn(arg);
+    }
+  }
+
+  void suspend_with(void (*fn)(void*), void* arg)
+  {
+    if (throw_if_cancelled_)
+      if (!!cancellation_state_.cancelled())
+        throw_error(boost::asio::error::operation_aborted, "yield");
+    has_context_switched_ = true;
+    on_suspend_fn_ = fn;
+    on_suspend_arg_ = arg;
+    caller_ = BOOST_ASIO_MOVE_CAST(fiber_type)(caller_).resume();
+  }
+
+  void destroy()
+  {
+    fiber_type callee = BOOST_ASIO_MOVE_CAST(fiber_type)(callee_);
+    (void)callee;
+  }
+
+private:
+  template <typename Function>
+  class entry_point
   {
   public:
-    typedef coro_handler<Handler, void> completion_handler_type;
-    typedef void return_type;
-
-    explicit coro_async_result(completion_handler_type& h)
-      : handler_(h),
-        ca_(h.ca_),
-        ready_(2)
+    template <typename F>
+    entry_point(BOOST_ASIO_MOVE_ARG(F) f,
+        spawned_fiber_thread** spawned_thread_out)
+      : function_(BOOST_ASIO_MOVE_CAST(F)(f)),
+        spawned_thread_out_(spawned_thread_out)
     {
-      h.ready_ = &ready_;
-      out_ec_ = h.ec_;
-      if (!out_ec_) h.ec_ = &ec_;
     }
 
-    void get()
+    fiber_type operator()(BOOST_ASIO_MOVE_ARG(fiber_type) caller)
     {
-      // Must not hold shared_ptr to coro while suspended.
-      handler_.coro_.reset();
-
-      if (--ready_ != 0)
-        ca_();
-      if (!out_ec_ && ec_) throw boost::system::system_error(ec_);
+      Function function(BOOST_ASIO_MOVE_CAST(Function)(function_));
+      spawned_fiber_thread spawned_thread(
+          BOOST_ASIO_MOVE_CAST(fiber_type)(caller));
+      *spawned_thread_out_ = &spawned_thread;
+      spawned_thread_out_ = 0;
+      spawned_thread.suspend();
+      function(&spawned_thread);
+      spawned_thread.suspend();
+      return {};
     }
 
   private:
-    completion_handler_type& handler_;
-    typename basic_yield_context<Handler>::caller_type& ca_;
-    atomic_count ready_;
-    boost::system::error_code* out_ec_;
-    boost::system::error_code ec_;
+    Function function_;
+    spawned_fiber_thread** spawned_thread_out_;
   };
 
+  fiber_type caller_;
+  fiber_type callee_;
+  void (*on_suspend_fn_)(void*);
+  void* on_suspend_arg_;
+};
+
+#endif // defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
+
+#if defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
+typedef spawned_fiber_thread default_spawned_thread_type;
+#elif defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+typedef spawned_coroutine_thread default_spawned_thread_type;
+#else
+# error No spawn() implementation available
+#endif
+
+// Helper class to ensure spawned threads are destroyed on the correct executor.
+class spawned_thread_destroyer
+{
+public:
+  explicit spawned_thread_destroyer(spawned_thread_base* spawned_thread)
+    : spawned_thread_(spawned_thread)
+  {
+    spawned_thread->detach();
+#if !defined(BOOST_ASIO_HAS_MOVE)
+    spawned_thread->attach(&spawned_thread_);
+#endif // !defined(BOOST_ASIO_HAS_MOVE)
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+
+  spawned_thread_destroyer(spawned_thread_destroyer&& other) BOOST_ASIO_NOEXCEPT
+    : spawned_thread_(other.spawned_thread_)
+  {
+    other.spawned_thread_ = 0;
+  }
+
+#else // defined(BOOST_ASIO_HAS_MOVE)
+
+  spawned_thread_destroyer(
+      const spawned_thread_destroyer& other) BOOST_ASIO_NOEXCEPT
+    : spawned_thread_(other.spawned_thread_)
+  {
+    spawned_thread_->detach();
+    spawned_thread_->attach(&spawned_thread_);
+  }
+
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  ~spawned_thread_destroyer()
+  {
+    if (spawned_thread_)
+      spawned_thread_->destroy();
+  }
+
+  void operator()()
+  {
+    if (spawned_thread_)
+    {
+      spawned_thread_->destroy();
+      spawned_thread_ = 0;
+    }
+  }
+
+private:
+  spawned_thread_base* spawned_thread_;
+};
+
+// Base class for all completion handlers associated with a spawned thread.
+template <typename Executor>
+class spawn_handler_base
+{
+public:
+  typedef Executor executor_type;
+  typedef cancellation_slot cancellation_slot_type;
+
+  spawn_handler_base(const basic_yield_context<Executor>& yield)
+    : executor_(yield.executor_),
+      spawned_thread_(yield.spawned_thread_),
+      ec_(yield.ec_)
+  {
+    spawned_thread_->detach();
+#if !defined(BOOST_ASIO_HAS_MOVE)
+    spawned_thread_->attach(&spawned_thread_);
+#endif // !defined(BOOST_ASIO_HAS_MOVE)
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+
+  spawn_handler_base(spawn_handler_base&& other) BOOST_ASIO_NOEXCEPT
+    : executor_(BOOST_ASIO_MOVE_CAST(Executor)(other.executor_)),
+      spawned_thread_(other.spawned_thread_),
+      ec_(other.ec_)
+  {
+    other.spawned_thread_ = 0;
+    other.ec_ = 0;
+  }
+
+#else // defined(BOOST_ASIO_HAS_MOVE)
+
+  spawn_handler_base(const spawn_handler_base& other) BOOST_ASIO_NOEXCEPT
+    : executor_(other.executor_),
+      spawned_thread_(other.spawned_thread_),
+      ec_(other.ec_)
+  {
+    spawned_thread_->detach();
+    spawned_thread_->attach(&spawned_thread_);
+  }
+
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  ~spawn_handler_base()
+  {
+    if (spawned_thread_)
+      (post)(executor_, spawned_thread_destroyer(spawned_thread_));
+  }
+
+  executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+  {
+    return executor_;
+  }
+
+  cancellation_slot_type get_cancellation_slot() const BOOST_ASIO_NOEXCEPT
+  {
+    return spawned_thread_->get_cancellation_slot();
+  }
+
+  void resume()
+  {
+#if defined(BOOST_ASIO_HAS_MOVE)
+    spawned_thread_->attach(&spawned_thread_);
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+    spawned_thread_->resume();
+  }
+
+protected:
+  Executor executor_;
+  spawned_thread_base* spawned_thread_;
+  boost::system::error_code* ec_;
+};
+
+// Helper class to perform the initial resume on the correct executor.
+template <typename Executor>
+class spawn_launcher
+  : public spawn_handler_base<Executor>
+{
+public:
+  spawn_launcher(const basic_yield_context<Executor>& yield)
+    : spawn_handler_base<Executor>(yield)
+  {
+  }
+
+  void operator()()
+  {
+    this->resume();
+  }
+};
+
+// Completion handlers for when basic_yield_context is used as a token.
+template <typename Executor, typename Signature>
+class spawn_handler;
+
+template <typename Executor, typename R>
+class spawn_handler<Executor, R()>
+  : public spawn_handler_base<Executor>
+{
+public:
+  typedef void return_type;
+
+  struct result_type {};
+
+  spawn_handler(const basic_yield_context<Executor>& yield, result_type&)
+    : spawn_handler_base<Executor>(yield)
+  {
+  }
+
+  void operator()()
+  {
+    this->resume();
+  }
+
+  static return_type on_resume(result_type&)
+  {
+  }
+};
+
+template <typename Executor, typename R>
+class spawn_handler<Executor, R(boost::system::error_code)>
+  : public spawn_handler_base<Executor>
+{
+public:
+  typedef void return_type;
+  typedef boost::system::error_code* result_type;
+
+  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
+    : spawn_handler_base<Executor>(yield),
+      result_(result)
+  {
+  }
+
+  void operator()(boost::system::error_code ec)
+  {
+    if (this->ec_)
+    {
+      *this->ec_ = ec;
+      result_ = 0;
+    }
+    else
+      result_ = &ec;
+    this->resume();
+  }
+
+  static return_type on_resume(result_type& result)
+  {
+    if (result)
+      throw_error(*result);
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename Executor, typename R>
+class spawn_handler<Executor, R(exception_ptr)>
+  : public spawn_handler_base<Executor>
+{
+public:
+  typedef void return_type;
+  typedef exception_ptr* result_type;
+
+  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
+    : spawn_handler_base<Executor>(yield),
+      result_(result)
+  {
+  }
+
+  void operator()(exception_ptr ex)
+  {
+    result_ = &ex;
+    this->resume();
+  }
+
+  static return_type on_resume(result_type& result)
+  {
+    if (result)
+      rethrow_exception(*result);
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename Executor, typename R, typename T>
+class spawn_handler<Executor, R(T)>
+  : public spawn_handler_base<Executor>
+{
+public:
+  typedef T return_type;
+  typedef return_type* result_type;
+
+  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
+    : spawn_handler_base<Executor>(yield),
+      result_(result)
+  {
+  }
+
+  void operator()(T value)
+  {
+    result_ = &value;
+    this->resume();
+  }
+
+  static return_type on_resume(result_type& result)
+  {
+    return BOOST_ASIO_MOVE_CAST(return_type)(*result);
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename Executor, typename R, typename T>
+class spawn_handler<Executor, R(boost::system::error_code, T)>
+  : public spawn_handler_base<Executor>
+{
+public:
+  typedef T return_type;
+
+  struct result_type
+  {
+    boost::system::error_code* ec_;
+    return_type* value_;
+  };
+
+  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
+    : spawn_handler_base<Executor>(yield),
+      result_(result)
+  {
+  }
+
+  void operator()(boost::system::error_code ec, T value)
+  {
+    if (this->ec_)
+    {
+      *this->ec_ = ec;
+      result_.ec_ = 0;
+    }
+    else
+      result_.ec_ = &ec;
+    result_.value_ = &value;
+    this->resume();
+  }
+
+  static return_type on_resume(result_type& result)
+  {
+    if (result.ec_)
+      throw_error(*result.ec_);
+    return BOOST_ASIO_MOVE_CAST(return_type)(*result.value_);
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename Executor, typename R, typename T>
+class spawn_handler<Executor, R(exception_ptr, T)>
+  : public spawn_handler_base<Executor>
+{
+public:
+  typedef T return_type;
+
+  struct result_type
+  {
+    exception_ptr ex_;
+    return_type* value_;
+  };
+
+  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
+    : spawn_handler_base<Executor>(yield),
+      result_(result)
+  {
+  }
+
+  void operator()(exception_ptr ex, T value)
+  {
+    result_.ex_ = &ex;
+    result_.value_ = &value;
+    this->resume();
+  }
+
+  static return_type on_resume(result_type& result)
+  {
+    if (result.ex_)
+      rethrow_exception(*result.ex_);
+    return BOOST_ASIO_MOVE_CAST(return_type)(*result.value_);
+  }
+
+private:
+  result_type& result_;
+};
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) \
+  && defined(BOOST_ASIO_HAS_STD_TUPLE)
+
+template <typename Executor, typename R, typename... Ts>
+class spawn_handler<Executor, R(Ts...)>
+  : public spawn_handler_base<Executor>
+{
+public:
+  typedef std::tuple<Ts...> return_type;
+
+  typedef return_type* result_type;
+
+  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
+    : spawn_handler_base<Executor>(yield),
+      result_(result)
+  {
+  }
+
+  template <typename... Args>
+  void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return_type value(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    result_ = &value;
+    this->resume();
+  }
+
+  static return_type on_resume(result_type& result)
+  {
+    return BOOST_ASIO_MOVE_CAST(return_type)(*result);
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename Executor, typename R, typename... Ts>
+class spawn_handler<Executor, R(boost::system::error_code, Ts...)>
+  : public spawn_handler_base<Executor>
+{
+public:
+  typedef std::tuple<Ts...> return_type;
+
+  struct result_type
+  {
+    boost::system::error_code* ec_;
+    return_type* value_;
+  };
+
+  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
+    : spawn_handler_base<Executor>(yield),
+      result_(result)
+  {
+  }
+
+  template <typename... Args>
+  void operator()(boost::system::error_code ec,
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return_type value(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    if (this->ec_)
+    {
+      *this->ec_ = ec;
+      result_.ec_ = 0;
+    }
+    else
+      result_.ec_ = &ec;
+    result_.value_ = &value;
+    this->resume();
+  }
+
+  static return_type on_resume(result_type& result)
+  {
+    if (result.ec_)
+      throw_error(*result.ec_);
+    return BOOST_ASIO_MOVE_CAST(return_type)(*result.value_);
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename Executor, typename R, typename... Ts>
+class spawn_handler<Executor, R(exception_ptr, Ts...)>
+  : public spawn_handler_base<Executor>
+{
+public:
+  typedef std::tuple<Ts...> return_type;
+
+  struct result_type
+  {
+    exception_ptr ex_;
+    return_type* value_;
+  };
+
+  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
+    : spawn_handler_base<Executor>(yield),
+      result_(result)
+  {
+  }
+
+  template <typename... Args>
+  void operator()(exception_ptr ex, BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return_type value(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    result_.ex_ = &ex;
+    result_.value_ = &value;
+    this->resume();
+  }
+
+  static return_type on_resume(result_type& result)
+  {
+    if (result.ex_)
+      rethrow_exception(*result.ex_);
+    return BOOST_ASIO_MOVE_CAST(return_type)(*result.value_);
+  }
+
+private:
+  result_type& result_;
+};
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+       //   && defined(BOOST_ASIO_HAS_STD_TUPLE)
+
+template <typename Executor, typename Signature>
+inline bool asio_handler_is_continuation(spawn_handler<Executor, Signature>*)
+{
+  return true;
+}
+
 } // namespace detail
 
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename Handler, typename ReturnType>
-class async_result<basic_yield_context<Handler>, ReturnType()>
-  : public detail::coro_async_result<Handler, void>
+template <typename Executor, typename Signature>
+class async_result<basic_yield_context<Executor>, Signature>
 {
 public:
-  explicit async_result(
-    typename detail::coro_async_result<Handler,
-      void>::completion_handler_type& h)
-    : detail::coro_async_result<Handler, void>(h)
-  {
-  }
-};
+  typedef typename detail::spawn_handler<Executor, Signature> handler_type;
+  typedef typename handler_type::return_type return_type;
 
-template <typename Handler, typename ReturnType, typename Arg1>
-class async_result<basic_yield_context<Handler>, ReturnType(Arg1)>
-  : public detail::coro_async_result<Handler, typename decay<Arg1>::type>
-{
-public:
-  explicit async_result(
-    typename detail::coro_async_result<Handler,
-      typename decay<Arg1>::type>::completion_handler_type& h)
-    : detail::coro_async_result<Handler, typename decay<Arg1>::type>(h)
-  {
-  }
-};
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
-template <typename Handler, typename ReturnType>
-class async_result<basic_yield_context<Handler>,
-    ReturnType(boost::system::error_code)>
-  : public detail::coro_async_result<Handler, void>
-{
-public:
-  explicit async_result(
-    typename detail::coro_async_result<Handler,
-      void>::completion_handler_type& h)
-    : detail::coro_async_result<Handler, void>(h)
+  template <typename Initiation, typename... InitArgs>
+  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation) init,
+      const basic_yield_context<Executor>& yield,
+      BOOST_ASIO_MOVE_ARG(InitArgs)... init_args)
   {
-  }
-};
+    typename handler_type::result_type result
+      = typename handler_type::result_type();
 
-template <typename Handler, typename ReturnType, typename Arg2>
-class async_result<basic_yield_context<Handler>,
-    ReturnType(boost::system::error_code, Arg2)>
-  : public detail::coro_async_result<Handler, typename decay<Arg2>::type>
-{
-public:
-  explicit async_result(
-    typename detail::coro_async_result<Handler,
-      typename decay<Arg2>::type>::completion_handler_type& h)
-    : detail::coro_async_result<Handler, typename decay<Arg2>::type>(h)
-  {
-  }
-};
+    yield.spawned_thread_->suspend_with(
+        [&]()
+        {
+          BOOST_ASIO_MOVE_CAST(Initiation)(init)(
+              handler_type(yield, result),
+              BOOST_ASIO_MOVE_CAST(InitArgs)(init_args)...);
+        });
 
-template <template <typename, typename> class Associator,
-    typename Handler, typename T, typename DefaultCandidate>
-struct associator<Associator,
-    detail::coro_handler<Handler, T>,
-    DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::coro_handler<Handler, T>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+    return handler_type::on_resume(result);
   }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation>
+  static return_type initiate(Initiation init,
+      const basic_yield_context<Executor>& yield)
+  {
+    typename handler_type::result_type result
+      = typename handler_type::result_type();
+
+    struct on_suspend
+    {
+      Initiation& init_;
+      const basic_yield_context<Executor>& yield_;
+      typename handler_type::result_type& result_;
+
+      void do_call()
+      {
+        BOOST_ASIO_MOVE_CAST(Initiation)(init_)(
+            handler_type(yield_, result_));
+      }
+
+      static void call(void* arg)
+      {
+        static_cast<on_suspend*>(arg)->do_call();
+      }
+    } o = { init, yield, result };
+
+    yield.spawned_thread_->suspend_with(&on_suspend::call, &o);
+
+    return handler_type::on_resume(result);
+  }
+
+#define BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS(n) \
+  BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_##n
+#define BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_1 \
+  T1& x1;
+#define BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_2 \
+  T1& x1; T2& x2;
+#define BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_3 \
+  T1& x1; T2& x2; T3& x3;
+#define BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_4 \
+  T1& x1; T2& x2; T3& x3; T4& x4;
+#define BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_5 \
+  T1& x1; T2& x2; T3& x3; T4& x4; T5& x5;
+#define BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_6 \
+  T1& x1; T2& x2; T3& x3; T4& x4; T5& x5; T6& x6;
+#define BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_7 \
+  T1& x1; T2& x2; T3& x3; T4& x4; T5& x5; T6& x6; T7& x7;
+#define BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_8 \
+  T1& x1; T2& x2; T3& x3; T4& x4; T5& x5; T6& x6; T7& x7; T8& x8;
+
+#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
+  template <typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  static return_type initiate(Initiation init, \
+      const basic_yield_context<Executor>& yield, \
+      BOOST_ASIO_VARIADIC_BYVAL_PARAMS(n)) \
+  { \
+    typename handler_type::result_type result \
+      = typename handler_type::result_type(); \
+  \
+    struct on_suspend \
+    { \
+      Initiation& init; \
+      const basic_yield_context<Executor>& yield; \
+      typename handler_type::result_type& result; \
+      BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS(n) \
+  \
+      void do_call() \
+      { \
+        BOOST_ASIO_MOVE_CAST(Initiation)(init)( \
+            handler_type(yield, result), \
+            BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+      } \
+  \
+      static void call(void* arg) \
+      { \
+        static_cast<on_suspend*>(arg)->do_call(); \
+      } \
+    } o = { init, yield, result, BOOST_ASIO_VARIADIC_BYVAL_ARGS(n) }; \
+  \
+    yield.spawned_thread_->suspend_with(&on_suspend::call, &o); \
+  \
+    return handler_type::on_resume(result); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF)
+#undef BOOST_ASIO_PRIVATE_INITIATE_DEF
+#undef BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS
+#undef BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_1
+#undef BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_2
+#undef BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_3
+#undef BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_4
+#undef BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_5
+#undef BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_6
+#undef BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_7
+#undef BOOST_ASIO_PRIVATE_ON_SUSPEND_MEMBERS_8
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 };
 
 namespace detail {
 
-  template <typename Handler, typename Function>
-  struct spawn_data : private noncopyable
+template <typename Executor, typename Function, typename Handler>
+class spawn_entry_point
+{
+public:
+  template <typename F, typename H>
+  spawn_entry_point(const Executor& ex,
+      BOOST_ASIO_MOVE_ARG(F) f, BOOST_ASIO_MOVE_ARG(H) h)
+    : executor_(ex),
+      function_(BOOST_ASIO_MOVE_CAST(F)(f)),
+      handler_(BOOST_ASIO_MOVE_CAST(H)(h))
   {
-    template <typename Hand, typename Func>
-    spawn_data(BOOST_ASIO_MOVE_ARG(Hand) handler,
-        bool call_handler, BOOST_ASIO_MOVE_ARG(Func) function)
-      : handler_(BOOST_ASIO_MOVE_CAST(Hand)(handler)),
-        call_handler_(call_handler),
-        function_(BOOST_ASIO_MOVE_CAST(Func)(function))
-    {
-    }
-
-    weak_ptr<typename basic_yield_context<Handler>::callee_type> coro_;
-    Handler handler_;
-    bool call_handler_;
-    Function function_;
-  };
-
-  template <typename Handler, typename Function>
-  struct coro_entry_point
-  {
-    void operator()(typename basic_yield_context<Handler>::caller_type& ca)
-    {
-      shared_ptr<spawn_data<Handler, Function> > data(data_);
-#if !defined(BOOST_COROUTINES_UNIDIRECT) && !defined(BOOST_COROUTINES_V2)
-      ca(); // Yield until coroutine pointer has been initialised.
-#endif // !defined(BOOST_COROUTINES_UNIDIRECT) && !defined(BOOST_COROUTINES_V2)
-      const basic_yield_context<Handler> yield(
-          data->coro_, ca, data->handler_);
-
-      (data->function_)(yield);
-      if (data->call_handler_)
-        BOOST_ASIO_MOVE_OR_LVALUE(Handler)(data->handler_)();
-    }
-
-    shared_ptr<spawn_data<Handler, Function> > data_;
-  };
-
-  template <typename Handler, typename Function>
-  struct spawn_helper
-  {
-    typedef typename associated_allocator<Handler>::type allocator_type;
-
-    allocator_type get_allocator() const BOOST_ASIO_NOEXCEPT
-    {
-      return (get_associated_allocator)(data_->handler_);
-    }
-
-    typedef typename associated_executor<Handler>::type executor_type;
-
-    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
-    {
-      return (get_associated_executor)(data_->handler_);
-    }
-
-    void operator()()
-    {
-      typedef typename basic_yield_context<Handler>::callee_type callee_type;
-      coro_entry_point<Handler, Function> entry_point = { data_ };
-      shared_ptr<callee_type> coro(new callee_type(entry_point, attributes_));
-      data_->coro_ = coro;
-      (*coro)();
-    }
-
-    shared_ptr<spawn_data<Handler, Function> > data_;
-    boost::coroutines::attributes attributes_;
-  };
-
-  template <typename Function, typename Handler, typename Function1>
-  inline asio_handler_invoke_is_deprecated
-  asio_handler_invoke(Function& function,
-      spawn_helper<Handler, Function1>* this_handler)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->data_->handler_);
-#if defined(BOOST_ASIO_NO_DEPRECATED)
-    return asio_handler_invoke_is_no_longer_used();
-#endif // defined(BOOST_ASIO_NO_DEPRECATED)
   }
 
-  template <typename Function, typename Handler, typename Function1>
-  inline asio_handler_invoke_is_deprecated
-  asio_handler_invoke(const Function& function,
-      spawn_helper<Handler, Function1>* this_handler)
+  void operator()(spawned_thread_base* spawned_thread)
   {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->data_->handler_);
-#if defined(BOOST_ASIO_NO_DEPRECATED)
-    return asio_handler_invoke_is_no_longer_used();
-#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+    const basic_yield_context<Executor> yield(spawned_thread, executor_);
+    this->call(yield,
+        void_type<typename result_of<Function(
+          basic_yield_context<Executor>)>::type>());
   }
 
-  inline void default_spawn_handler() {}
+private:
+  void call(const basic_yield_context<Executor>& yield, void_type<void>)
+  {
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    try
+#endif // !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    {
+      function_(yield);
+      if (!yield.spawned_thread_->has_context_switched())
+        (post)(yield);
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(exception_ptr());
+    }
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    catch (...)
+    {
+      exception_ptr ex = current_exception();
+      if (!yield.spawned_thread_->has_context_switched())
+        (post)(yield);
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(ex);
+    }
+#endif // !defined(BOOST_ASIO_NO_EXCEPTIONS)
+  }
+
+  template <typename T>
+  void call(const basic_yield_context<Executor>& yield, void_type<T>)
+  {
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    try
+#endif // !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    {
+      T result(function_(yield));
+      if (!yield.spawned_thread_->has_context_switched())
+        (post)(yield);
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+          exception_ptr(), BOOST_ASIO_MOVE_CAST(T)(result));
+    }
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+    catch (...)
+    {
+      exception_ptr ex = current_exception();
+      if (!yield.spawned_thread_->has_context_switched())
+        (post)(yield);
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(ex, T());
+    }
+#endif // !defined(BOOST_ASIO_NO_EXCEPTIONS)
+  }
+
+  Executor executor_;
+  Function function_;
+  Handler handler_;
+};
+
+struct spawn_cancellation_signal_emitter
+{
+  cancellation_signal* signal_;
+  cancellation_type_t type_;
+
+  void operator()()
+  {
+    signal_->emit(type_);
+  }
+};
+
+template <typename Handler, typename Executor, typename = void>
+class spawn_cancellation_handler
+{
+public:
+  spawn_cancellation_handler(const Handler& handler, const Executor& ex)
+    : ex_(boost::asio::get_associated_executor(handler, ex))
+  {
+  }
+
+  cancellation_slot slot()
+  {
+    return signal_.slot();
+  }
+
+  void operator()(cancellation_type_t type)
+  {
+    spawn_cancellation_signal_emitter emitter = { &signal_, type };
+    (dispatch)(ex_, emitter);
+  }
+
+private:
+  cancellation_signal signal_;
+  typename associated_executor<Handler, Executor>::type ex_;
+};
+
+
+template <typename Handler, typename Executor>
+class spawn_cancellation_handler<Handler, Executor,
+    typename enable_if<
+      is_same<
+        typename associated_executor<Handler,
+          Executor>::asio_associated_executor_is_unspecialised,
+        void
+      >::value
+    >::type>
+{
+public:
+  spawn_cancellation_handler(const Handler&, const Executor&)
+  {
+  }
+
+  cancellation_slot slot()
+  {
+    return signal_.slot();
+  }
+
+  void operator()(cancellation_type_t type)
+  {
+    signal_.emit(type);
+  }
+
+private:
+  cancellation_signal signal_;
+};
+
+template <typename Executor>
+class initiate_spawn
+{
+public:
+  typedef Executor executor_type;
+
+  explicit initiate_spawn(const executor_type& ex)
+    : executor_(ex)
+  {
+  }
+
+  executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+  {
+    return executor_;
+  }
+
+  template <typename Handler, typename F>
+  void operator()(BOOST_ASIO_MOVE_ARG(Handler) handler,
+      BOOST_ASIO_MOVE_ARG(F) f) const
+  {
+    typedef typename decay<Handler>::type handler_type;
+    typedef typename decay<F>::type function_type;
+    typedef spawn_cancellation_handler<
+      handler_type, Executor> cancel_handler_type;
+
+    typename associated_cancellation_slot<handler_type>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    cancel_handler_type* cancel_handler = slot.is_connected()
+      ? &slot.template emplace<cancel_handler_type>(handler, executor_)
+      : 0;
+
+    cancellation_slot proxy_slot(
+        cancel_handler
+          ? cancel_handler->slot()
+          : cancellation_slot());
+
+    cancellation_state cancel_state(proxy_slot);
+
+    (dispatch)(executor_,
+        spawn_launcher<Executor>(
+          basic_yield_context<Executor>(
+            default_spawned_thread_type::spawn(
+              spawn_entry_point<Executor, function_type, handler_type>(
+                executor_, BOOST_ASIO_MOVE_CAST(F)(f),
+                BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+              proxy_slot, cancel_state), executor_)));
+  }
+
+#if defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
+
+  template <typename Handler, typename StackAllocator, typename F>
+  void operator()(BOOST_ASIO_MOVE_ARG(Handler) handler, allocator_arg_t,
+      BOOST_ASIO_MOVE_ARG(StackAllocator) stack_allocator,
+      BOOST_ASIO_MOVE_ARG(F) f) const
+  {
+    typedef typename decay<Handler>::type handler_type;
+    typedef typename decay<F>::type function_type;
+    typedef spawn_cancellation_handler<
+      handler_type, Executor> cancel_handler_type;
+
+    typename associated_cancellation_slot<handler_type>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    cancel_handler_type* cancel_handler = slot.is_connected()
+      ? &slot.template emplace<cancel_handler_type>(handler, executor_)
+      : 0;
+
+    cancellation_slot proxy_slot(
+        cancel_handler
+          ? cancel_handler->slot()
+          : cancellation_slot());
+
+    cancellation_state cancel_state(proxy_slot);
+
+    (dispatch)(executor_,
+        spawn_launcher<Executor>(
+          basic_yield_context<Executor>(
+            spawned_fiber_thread::spawn(allocator_arg_t(),
+              BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
+              spawn_entry_point<Executor, function_type, handler_type>(
+                executor_, BOOST_ASIO_MOVE_CAST(F)(f),
+                BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+              proxy_slot, cancel_state), executor_)));
+  }
+
+#endif // defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
+
+private:
+  executor_type executor_;
+};
+
+} // namespace detail
+
+template <typename Executor, typename F,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+        CompletionToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
+    typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+spawn(const Executor& ex, BOOST_ASIO_MOVE_ARG(F) function,
+    BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+#if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+    typename constraint<
+      !is_same<
+        typename decay<CompletionToken>::type,
+        boost::coroutines::attributes
+      >::value
+    >::type,
+#endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken,
+      typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
+          declval<detail::initiate_spawn<Executor> >(),
+          token, BOOST_ASIO_MOVE_CAST(F)(function))))
+{
+  return async_initiate<CompletionToken,
+    typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
+        detail::initiate_spawn<Executor>(ex),
+        token, BOOST_ASIO_MOVE_CAST(F)(function));
+}
+
+template <typename ExecutionContext, typename F,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<
+        typename ExecutionContext::executor_type>)>::type>::type)
+          CompletionToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
+    typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<
+        typename ExecutionContext::executor_type>)>::type>::type)
+spawn(ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(F) function,
+    BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+#if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+    typename constraint<
+      !is_same<
+        typename decay<CompletionToken>::type,
+        boost::coroutines::attributes
+      >::value
+    >::type,
+#endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+    typename constraint<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    >::type)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken,
+      typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<
+          typename ExecutionContext::executor_type>)>::type>::type>(
+            declval<detail::initiate_spawn<
+              typename ExecutionContext::executor_type> >(),
+            token, BOOST_ASIO_MOVE_CAST(F)(function))))
+{
+  return (spawn)(ctx.get_executor(), BOOST_ASIO_MOVE_CAST(F)(function),
+      BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
+}
+
+template <typename Executor, typename F,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+        CompletionToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
+    typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+spawn(const basic_yield_context<Executor>& ctx,
+    BOOST_ASIO_MOVE_ARG(F) function,
+    BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+#if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+    typename constraint<
+      !is_same<
+        typename decay<CompletionToken>::type,
+        boost::coroutines::attributes
+      >::value
+    >::type,
+#endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken,
+      typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
+          declval<detail::initiate_spawn<Executor> >(),
+          token, BOOST_ASIO_MOVE_CAST(F)(function))))
+{
+  return (spawn)(ctx.get_executor(), BOOST_ASIO_MOVE_CAST(F)(function),
+      BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
+}
+
+#if defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
+
+template <typename Executor, typename StackAllocator, typename F,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+        CompletionToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
+    typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+spawn(const Executor& ex, allocator_arg_t,
+    BOOST_ASIO_MOVE_ARG(StackAllocator) stack_allocator,
+    BOOST_ASIO_MOVE_ARG(F) function,
+    BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken,
+      typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
+          declval<detail::initiate_spawn<Executor> >(),
+          token, allocator_arg_t(),
+          BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
+          BOOST_ASIO_MOVE_CAST(F)(function))))
+{
+  return async_initiate<CompletionToken,
+    typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
+        detail::initiate_spawn<Executor>(ex), token, allocator_arg_t(),
+        BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
+        BOOST_ASIO_MOVE_CAST(F)(function));
+}
+
+template <typename ExecutionContext, typename StackAllocator, typename F,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<
+        typename ExecutionContext::executor_type>)>::type>::type)
+          CompletionToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
+    typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<
+        typename ExecutionContext::executor_type>)>::type>::type)
+spawn(ExecutionContext& ctx, allocator_arg_t,
+    BOOST_ASIO_MOVE_ARG(StackAllocator) stack_allocator,
+    BOOST_ASIO_MOVE_ARG(F) function,
+    BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+    typename constraint<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    >::type)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken,
+      typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<
+          typename ExecutionContext::executor_type>)>::type>::type>(
+            declval<detail::initiate_spawn<
+              typename ExecutionContext::executor_type> >(),
+            token, allocator_arg_t(),
+            BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
+            BOOST_ASIO_MOVE_CAST(F)(function))))
+{
+  return (spawn)(ctx.get_executor(), allocator_arg_t(),
+      BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
+      BOOST_ASIO_MOVE_CAST(F)(function),
+      BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
+}
+
+template <typename Executor, typename StackAllocator, typename F,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+        CompletionToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
+    typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+spawn(const basic_yield_context<Executor>& ctx, allocator_arg_t,
+    BOOST_ASIO_MOVE_ARG(StackAllocator) stack_allocator,
+    BOOST_ASIO_MOVE_ARG(F) function,
+    BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken,
+      typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
+          declval<detail::initiate_spawn<Executor> >(),
+          token, allocator_arg_t(),
+          BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
+          BOOST_ASIO_MOVE_CAST(F)(function))))
+{
+  return (spawn)(ctx.get_executor(), allocator_arg_t(),
+      BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
+      BOOST_ASIO_MOVE_CAST(F)(function),
+      BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
+}
+
+#endif // defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
+
+#if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+
+namespace detail {
+
+template <typename Executor, typename Function, typename Handler>
+class old_spawn_entry_point
+{
+public:
+  template <typename F, typename H>
+  old_spawn_entry_point(const Executor& ex,
+      BOOST_ASIO_MOVE_ARG(F) f, BOOST_ASIO_MOVE_ARG(H) h)
+    : executor_(ex),
+      function_(BOOST_ASIO_MOVE_CAST(F)(f)),
+      handler_(BOOST_ASIO_MOVE_CAST(H)(h))
+  {
+  }
+
+  void operator()(spawned_thread_base* spawned_thread)
+  {
+    const basic_yield_context<Executor> yield(spawned_thread, executor_);
+    this->call(yield,
+        void_type<typename result_of<Function(
+          basic_yield_context<Executor>)>::type>());
+  }
+
+private:
+  void call(const basic_yield_context<Executor>& yield, void_type<void>)
+  {
+    function_(yield);
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)();
+  }
+
+  template <typename T>
+  void call(const basic_yield_context<Executor>& yield, void_type<T>)
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(function_(yield));
+  }
+
+  Executor executor_;
+  Function function_;
+  Handler handler_;
+};
+
+inline void default_spawn_handler() {}
 
 } // namespace detail
 
@@ -432,34 +1382,36 @@ void spawn(BOOST_ASIO_MOVE_ARG(Handler) handler,
 {
   typedef typename decay<Handler>::type handler_type;
   typedef typename decay<Function>::type function_type;
+  typedef typename associated_executor<handler_type>::type executor_type;
 
-  detail::spawn_helper<handler_type, function_type> helper;
-  helper.data_.reset(
-      new detail::spawn_data<handler_type, function_type>(
-        BOOST_ASIO_MOVE_CAST(Handler)(handler), true,
-        BOOST_ASIO_MOVE_CAST(Function)(function)));
-  helper.attributes_ = attributes;
+  executor_type ex((get_associated_executor)(handler));
 
-  boost::asio::dispatch(helper);
+  (dispatch)(ex,
+      detail::spawn_launcher<executor_type>(
+        basic_yield_context<executor_type>(
+          detail::spawned_coroutine_thread::spawn(
+            detail::old_spawn_entry_point<executor_type,
+              function_type, void (*)()>(
+                ex, BOOST_ASIO_MOVE_CAST(Function)(function),
+                &detail::default_spawn_handler), attributes), ex)));
 }
 
-template <typename Handler, typename Function>
-void spawn(basic_yield_context<Handler> ctx,
+template <typename Executor, typename Function>
+void spawn(basic_yield_context<Executor> ctx,
     BOOST_ASIO_MOVE_ARG(Function) function,
     const boost::coroutines::attributes& attributes)
 {
   typedef typename decay<Function>::type function_type;
 
-  Handler handler(ctx.handler_); // Explicit copy that might be moved from.
-
-  detail::spawn_helper<Handler, function_type> helper;
-  helper.data_.reset(
-      new detail::spawn_data<Handler, function_type>(
-        BOOST_ASIO_MOVE_CAST(Handler)(handler), false,
-        BOOST_ASIO_MOVE_CAST(Function)(function)));
-  helper.attributes_ = attributes;
-
-  boost::asio::dispatch(helper);
+  (dispatch)(ctx.get_executor(),
+      detail::spawn_launcher<Executor>(
+        basic_yield_context<Executor>(
+          detail::spawned_coroutine_thread::spawn(
+            detail::old_spawn_entry_point<Executor,
+              function_type, void (*)()>(ctx.get_executor(),
+                BOOST_ASIO_MOVE_CAST(Function)(function),
+                &detail::default_spawn_handler), attributes),
+          ctx.get_executor())));
 }
 
 template <typename Function, typename Executor>
@@ -509,7 +1461,7 @@ inline void spawn(ExecutionContext& ctx,
       BOOST_ASIO_MOVE_CAST(Function)(function), attributes);
 }
 
-#endif // !defined(GENERATING_DOCUMENTATION)
+#endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
 
 } // namespace asio
 } // namespace boost
diff --git a/include/boost/asio/spawn.hpp b/include/boost/asio/spawn.hpp
index 35263606..a72a8a49 100644
--- a/include/boost/asio/spawn.hpp
+++ b/include/boost/asio/spawn.hpp
@@ -16,20 +16,151 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/coroutine/all.hpp>
 #include <boost/asio/any_io_executor.hpp>
-#include <boost/asio/bind_executor.hpp>
+#include <boost/asio/cancellation_signal.hpp>
+#include <boost/asio/cancellation_state.hpp>
+#include <boost/asio/detail/exception.hpp>
 #include <boost/asio/detail/memory.hpp>
 #include <boost/asio/detail/type_traits.hpp>
-#include <boost/asio/detail/wrapped_handler.hpp>
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/is_executor.hpp>
 #include <boost/asio/strand.hpp>
 
+#if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+# include <boost/coroutine/all.hpp>
+#endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
+namespace detail {
+
+// Base class for all spawn()-ed thread implementations.
+class spawned_thread_base
+{
+public:
+  spawned_thread_base()
+    : owner_(0),
+      has_context_switched_(false),
+      throw_if_cancelled_(false)
+  {
+  }
+
+  virtual ~spawned_thread_base() {}
+  virtual void resume() = 0;
+  virtual void suspend_with(void (*fn)(void*), void* arg) = 0;
+  virtual void destroy() = 0;
+
+  void attach(spawned_thread_base** owner)
+  {
+    owner_ = owner;
+    *owner_ = this;
+  }
+
+  void detach()
+  {
+    if (owner_)
+      *owner_ = 0;
+    owner_ = 0;
+  }
+
+  void suspend()
+  {
+    suspend_with(0, 0);
+  }
+
+  template <typename F>
+  void suspend_with(F f)
+  {
+    suspend_with(&spawned_thread_base::call<F>, &f);
+  }
+
+  cancellation_slot get_cancellation_slot() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_state_.slot();
+  }
+
+  cancellation_state get_cancellation_state() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_state_;
+  }
+
+  void reset_cancellation_state()
+  {
+    cancellation_state_ = cancellation_state(parent_cancellation_slot_);
+  }
+
+  template <typename Filter>
+  void reset_cancellation_state(Filter filter)
+  {
+    cancellation_state_ = cancellation_state(
+        parent_cancellation_slot_, filter, filter);
+  }
+
+  template <typename InFilter, typename OutFilter>
+  void reset_cancellation_state(InFilter in_filter, OutFilter out_filter)
+  {
+    cancellation_state_ = cancellation_state(
+        parent_cancellation_slot_, in_filter, out_filter);
+  }
+
+  cancellation_type_t cancelled() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_state_.cancelled();
+  }
+
+  bool has_context_switched() const BOOST_ASIO_NOEXCEPT
+  {
+    return has_context_switched_;
+  }
+
+  bool throw_if_cancelled() const BOOST_ASIO_NOEXCEPT
+  {
+    return throw_if_cancelled_;
+  }
+
+  void throw_if_cancelled(bool value) BOOST_ASIO_NOEXCEPT
+  {
+    throw_if_cancelled_ = value;
+  }
+
+protected:
+  spawned_thread_base** owner_; // Points to data member in active handler.
+  boost::asio::cancellation_slot parent_cancellation_slot_;
+  boost::asio::cancellation_state cancellation_state_;
+  bool has_context_switched_;
+  bool throw_if_cancelled_;
+
+private:
+  // Disallow copying and assignment.
+  spawned_thread_base(const spawned_thread_base&) BOOST_ASIO_DELETED;
+  spawned_thread_base& operator=(const spawned_thread_base&) BOOST_ASIO_DELETED;
+
+  template <typename F>
+  static void call(void* f)
+  {
+    (*static_cast<F*>(f))();
+  }
+};
+
+
+template <typename T>
+struct spawn_signature
+{
+  typedef void type(exception_ptr, T);
+};
+
+template <>
+struct spawn_signature<void>
+{
+  typedef void type(exception_ptr);
+};
+
+template <typename Executor>
+class initiate_spawn;
+
+} // namespace detail
 
 /// A @ref completion_token that represents the currently executing coroutine.
 /**
@@ -38,8 +169,8 @@ namespace asio {
  * object may be passed as a completion token to an asynchronous operation. For
  * example:
  *
- * @code template <typename Handler>
- * void my_coroutine(basic_yield_context<Handler> yield)
+ * @code template <typename Executor>
+ * void my_coroutine(basic_yield_context<Executor> yield)
  * {
  *   ...
  *   std::size_t n = my_socket.async_read_some(buffer, yield);
@@ -50,69 +181,114 @@ namespace asio {
  * current coroutine. The coroutine is resumed when the asynchronous operation
  * completes, and the result of the operation is returned.
  */
-template <typename Handler>
+template <typename Executor>
 class basic_yield_context
 {
 public:
-  /// The coroutine callee type, used by the implementation.
-  /**
-   * When using Boost.Coroutine v1, this type is:
-   * @code typename coroutine<void()> @endcode
-   * When using Boost.Coroutine v2 (unidirectional coroutines), this type is:
-   * @code push_coroutine<void> @endcode
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined callee_type;
-#elif defined(BOOST_COROUTINES_UNIDIRECT) || defined(BOOST_COROUTINES_V2)
-  typedef boost::coroutines::push_coroutine<void> callee_type;
-#else
-  typedef boost::coroutines::coroutine<void()> callee_type;
-#endif
-  
-  /// The coroutine caller type, used by the implementation.
-  /**
-   * When using Boost.Coroutine v1, this type is:
-   * @code typename coroutine<void()>::caller_type @endcode
-   * When using Boost.Coroutine v2 (unidirectional coroutines), this type is:
-   * @code pull_coroutine<void> @endcode
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined caller_type;
-#elif defined(BOOST_COROUTINES_UNIDIRECT) || defined(BOOST_COROUTINES_V2)
-  typedef boost::coroutines::pull_coroutine<void> caller_type;
-#else
-  typedef boost::coroutines::coroutine<void()>::caller_type caller_type;
-#endif
+  /// The executor type associated with the yield context.
+  typedef Executor executor_type;
 
-  /// Construct a yield context to represent the specified coroutine.
-  /**
-   * Most applications do not need to use this constructor. Instead, the
-   * spawn() function passes a yield context as an argument to the coroutine
-   * function.
-   */
-  basic_yield_context(
-      const detail::weak_ptr<callee_type>& coro,
-      caller_type& ca, Handler& handler)
-    : coro_(coro),
-      ca_(ca),
-      handler_(handler),
-      ec_(0)
-  {
-  }
+  /// The cancellation slot type associated with the yield context.
+  typedef cancellation_slot cancellation_slot_type;
 
   /// Construct a yield context from another yield context type.
   /**
-   * Requires that OtherHandler be convertible to Handler.
+   * Requires that OtherExecutor be convertible to Executor.
    */
-  template <typename OtherHandler>
-  basic_yield_context(const basic_yield_context<OtherHandler>& other)
-    : coro_(other.coro_),
-      ca_(other.ca_),
-      handler_(other.handler_),
+  template <typename OtherExecutor>
+  basic_yield_context(const basic_yield_context<OtherExecutor>& other,
+      typename constraint<
+        is_convertible<OtherExecutor, Executor>::value
+      >::type = 0)
+    : spawned_thread_(other.spawned_thread_),
+      executor_(other.executor_),
       ec_(other.ec_)
   {
   }
 
+  /// Get the executor associated with the yield context.
+  executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+  {
+    return executor_;
+  }
+
+  /// Get the cancellation slot associated with the coroutine.
+  cancellation_slot_type get_cancellation_slot() const BOOST_ASIO_NOEXCEPT
+  {
+    return spawned_thread_->get_cancellation_slot();
+  }
+
+  /// Get the cancellation state associated with the coroutine.
+  cancellation_state get_cancellation_state() const BOOST_ASIO_NOEXCEPT
+  {
+    return spawned_thread_->get_cancellation_state();
+  }
+
+  /// Reset the cancellation state associated with the coroutine.
+  /**
+   * Let <tt>P</tt> be the cancellation slot associated with the current
+   * coroutine's @ref spawn completion handler. Assigns a new
+   * boost::asio::cancellation_state object <tt>S</tt>, constructed as
+   * <tt>S(P)</tt>, into the current coroutine's cancellation state object.
+   */
+  void reset_cancellation_state() const
+  {
+    spawned_thread_->reset_cancellation_state();
+  }
+
+  /// Reset the cancellation state associated with the coroutine.
+  /**
+   * Let <tt>P</tt> be the cancellation slot associated with the current
+   * coroutine's @ref spawn completion handler. Assigns a new
+   * boost::asio::cancellation_state object <tt>S</tt>, constructed as <tt>S(P,
+   * std::forward<Filter>(filter))</tt>, into the current coroutine's
+   * cancellation state object.
+   */
+  template <typename Filter>
+  void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(Filter) filter) const
+  {
+    spawned_thread_->reset_cancellation_state(
+        BOOST_ASIO_MOVE_CAST(Filter)(filter));
+  }
+
+  /// Reset the cancellation state associated with the coroutine.
+  /**
+   * Let <tt>P</tt> be the cancellation slot associated with the current
+   * coroutine's @ref spawn completion handler. Assigns a new
+   * boost::asio::cancellation_state object <tt>S</tt>, constructed as <tt>S(P,
+   * std::forward<InFilter>(in_filter),
+   * std::forward<OutFilter>(out_filter))</tt>, into the current coroutine's
+   * cancellation state object.
+   */
+  template <typename InFilter, typename OutFilter>
+  void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
+      BOOST_ASIO_MOVE_ARG(OutFilter) out_filter) const
+  {
+    spawned_thread_->reset_cancellation_state(
+        BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
+        BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter));
+  }
+
+  /// Determine whether the current coroutine has been cancelled.
+  cancellation_type_t cancelled() const BOOST_ASIO_NOEXCEPT
+  {
+    return spawned_thread_->cancelled();
+  }
+
+  /// Determine whether the coroutine throws if trying to suspend when it has
+  /// been cancelled.
+  bool throw_if_cancelled() const BOOST_ASIO_NOEXCEPT
+  {
+    return spawned_thread_->throw_if_cancelled();
+  }
+
+  /// Set whether the coroutine throws if trying to suspend when it has been
+  /// cancelled.
+  void throw_if_cancelled(bool value) const BOOST_ASIO_NOEXCEPT
+  {
+    spawned_thread_->throw_if_cancelled(value);
+  }
+
   /// Return a yield context that sets the specified error_code.
   /**
    * By default, when a yield context is used with an asynchronous operation, a
@@ -120,8 +296,8 @@ public:
    * operator may be used to specify an error_code object that should instead be
    * set with the asynchronous operation's result. For example:
    *
-   * @code template <typename Handler>
-   * void my_coroutine(basic_yield_context<Handler> yield)
+   * @code template <typename Executor>
+   * void my_coroutine(basic_yield_context<Executor> yield)
    * {
    *   ...
    *   std::size_t n = my_socket.async_read_some(buffer, yield[ec]);
@@ -139,23 +315,25 @@ public:
     return tmp;
   }
 
-#if defined(GENERATING_DOCUMENTATION)
-private:
-#endif // defined(GENERATING_DOCUMENTATION)
-  detail::weak_ptr<callee_type> coro_;
-  caller_type& ca_;
-  Handler handler_;
+#if !defined(GENERATING_DOCUMENTATION)
+//private:
+  basic_yield_context(detail::spawned_thread_base* spawned_thread,
+      const Executor& ex)
+    : spawned_thread_(spawned_thread),
+      executor_(ex),
+      ec_(0)
+  {
+  }
+
+  detail::spawned_thread_base* spawned_thread_;
+  Executor executor_;
   boost::system::error_code* ec_;
+#endif // !defined(GENERATING_DOCUMENTATION)
 };
 
-#if defined(GENERATING_DOCUMENTATION)
 /// A @ref completion_token object that represents the currently executing
 /// coroutine.
-typedef basic_yield_context<unspecified> yield_context;
-#else // defined(GENERATING_DOCUMENTATION)
-typedef basic_yield_context<
-  executor_binder<void(*)(), any_io_executor> > yield_context;
-#endif // defined(GENERATING_DOCUMENTATION)
+typedef basic_yield_context<any_io_executor> yield_context;
 
 /**
  * @defgroup spawn boost::asio::spawn
@@ -166,7 +344,7 @@ typedef basic_yield_context<
  * library. This function enables programs to implement asynchronous logic in a
  * synchronous manner, as illustrated by the following example:
  *
- * @code boost::asio::spawn(my_strand, do_echo);
+ * @code boost::asio::spawn(my_strand, do_echo, boost::asio::detached);
  *
  * // ...
  *
@@ -193,13 +371,275 @@ typedef basic_yield_context<
  */
 /*@{*/
 
-/// Start a new stackful coroutine, calling the specified handler when it
-/// completes.
+/// Start a new stackful coroutine that executes on a given executor.
+/**
+ * This function is used to launch a new stackful coroutine.
+ *
+ * @param ex Identifies the executor that will run the stackful coroutine.
+ *
+ * @param function The coroutine function. The function must be callable the
+ * signature:
+ * @code void function(basic_yield_context<Executor> yield); @endcode
+ */
+template <typename Executor, typename F,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+        CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
+    typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+spawn(const Executor& ex, BOOST_ASIO_MOVE_ARG(F) function,
+    BOOST_ASIO_MOVE_ARG(CompletionToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+#if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+    typename constraint<
+      !is_same<
+        typename decay<CompletionToken>::type,
+        boost::coroutines::attributes
+      >::value
+    >::type = 0,
+#endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type = 0)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken,
+      typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
+          declval<detail::initiate_spawn<Executor> >(),
+          token, BOOST_ASIO_MOVE_CAST(F)(function))));
+
+/// Start a new stackful coroutine that executes on a given execution context.
+/**
+ * This function is used to launch a new stackful coroutine.
+ *
+ * @param ctx Identifies the execution context that will run the stackful
+ * coroutine.
+ *
+ * @param function The coroutine function. The function must be callable the
+ * signature:
+ * @code void function(basic_yield_context<Executor> yield); @endcode
+ */
+template <typename ExecutionContext, typename F,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<
+        typename ExecutionContext::executor_type>)>::type>::type)
+          CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
+            typename ExecutionContext::executor_type)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
+    typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<
+        typename ExecutionContext::executor_type>)>::type>::type)
+spawn(ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(F) function,
+    BOOST_ASIO_MOVE_ARG(CompletionToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
+        typename ExecutionContext::executor_type),
+#if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+    typename constraint<
+      !is_same<
+        typename decay<CompletionToken>::type,
+        boost::coroutines::attributes
+      >::value
+    >::type = 0,
+#endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+    typename constraint<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    >::type = 0)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken,
+      typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<
+          typename ExecutionContext::executor_type>)>::type>::type>(
+            declval<detail::initiate_spawn<
+              typename ExecutionContext::executor_type> >(),
+            token, BOOST_ASIO_MOVE_CAST(F)(function))));
+
+/// Start a new stackful coroutine, inheriting the executor of another.
+/**
+ * This function is used to launch a new stackful coroutine.
+ *
+ * @param ctx Identifies the current coroutine as a parent of the new
+ * coroutine. This specifies that the new coroutine should inherit the executor
+ * of the parent. For example, if the parent coroutine is executing in a
+ * particular strand, then the new coroutine will execute in the same strand.
+ *
+ * @param function The coroutine function. The function must be callable the
+ * signature:
+ * @code void function(basic_yield_context<Executor> yield); @endcode
+ */
+template <typename Executor, typename F,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+        CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
+    typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+spawn(const basic_yield_context<Executor>& ctx,
+    BOOST_ASIO_MOVE_ARG(F) function,
+    BOOST_ASIO_MOVE_ARG(CompletionToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+#if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+    typename constraint<
+      !is_same<
+        typename decay<CompletionToken>::type,
+        boost::coroutines::attributes
+      >::value
+    >::type = 0,
+#endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type = 0)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken,
+      typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
+          declval<detail::initiate_spawn<Executor> >(),
+          token, BOOST_ASIO_MOVE_CAST(F)(function))));
+
+#if defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Start a new stackful coroutine that executes on a given executor.
+/**
+ * This function is used to launch a new stackful coroutine using the
+ * specified stack allocator.
+ *
+ * @param ex Identifies the executor that will run the stackful coroutine.
+ *
+ * @param stack_allocator Denotes the allocator to be used to allocate the
+ * underlying coroutine's stack. The type must satisfy the stack-allocator
+ * concept defined by the Boost.Context library.
+ *
+ * @param function The coroutine function. The function must be callable the
+ * signature:
+ * @code void function(basic_yield_context<Executor> yield); @endcode
+ */
+template <typename Executor, typename StackAllocator, typename F,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+        CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
+    typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+spawn(const Executor& ex, allocator_arg_t,
+    BOOST_ASIO_MOVE_ARG(StackAllocator) stack_allocator,
+    BOOST_ASIO_MOVE_ARG(F) function,
+    BOOST_ASIO_MOVE_ARG(CompletionToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type = 0)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken,
+      typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
+          declval<detail::initiate_spawn<Executor> >(),
+          token, allocator_arg_t(),
+          BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
+          BOOST_ASIO_MOVE_CAST(F)(function))));
+
+/// Start a new stackful coroutine that executes on a given execution context.
+/**
+ * This function is used to launch a new stackful coroutine.
+ *
+ * @param ctx Identifies the execution context that will run the stackful
+ * coroutine.
+ *
+ * @param stack_allocator Denotes the allocator to be used to allocate the
+ * underlying coroutine's stack. The type must satisfy the stack-allocator
+ * concept defined by the Boost.Context library.
+ *
+ * @param function The coroutine function. The function must be callable the
+ * signature:
+ * @code void function(basic_yield_context<Executor> yield); @endcode
+ */
+template <typename ExecutionContext, typename StackAllocator, typename F,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<
+        typename ExecutionContext::executor_type>)>::type>::type)
+          CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
+            typename ExecutionContext::executor_type)>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
+    typename detail::spawn_signature<
+      typename result_of<F(basic_yield_context<
+        typename ExecutionContext::executor_type>)>::type>::type)
+spawn(ExecutionContext& ctx, allocator_arg_t,
+    BOOST_ASIO_MOVE_ARG(StackAllocator) stack_allocator,
+    BOOST_ASIO_MOVE_ARG(F) function,
+    BOOST_ASIO_MOVE_ARG(CompletionToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
+        typename ExecutionContext::executor_type),
+    typename constraint<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    >::type = 0)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken,
+      typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<
+          typename ExecutionContext::executor_type>)>::type>::type>(
+            declval<detail::initiate_spawn<
+              typename ExecutionContext::executor_type> >(),
+            token, allocator_arg_t(),
+            BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
+            BOOST_ASIO_MOVE_CAST(F)(function))));
+
+  /// Start a new stackful coroutine, inheriting the executor of another.
+  /**
+   * This function is used to launch a new stackful coroutine using the
+   * specified stack allocator.
+   *
+   * @param ctx Identifies the current coroutine as a parent of the new
+   * coroutine. This specifies that the new coroutine should inherit the
+   * executor of the parent. For example, if the parent coroutine is executing
+   * in a particular strand, then the new coroutine will execute in the same
+   * strand.
+   *
+   * @param stack_allocator Denotes the allocator to be used to allocate the
+   * underlying coroutine's stack. The type must satisfy the stack-allocator
+   * concept defined by the Boost.Context library.
+   *
+   * @param function The coroutine function. The function must be callable the
+   * signature:
+   * @code void function(basic_yield_context<Executor> yield); @endcode
+   */
+  template <typename Executor, typename StackAllocator, typename F,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+          CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
+      typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<Executor>)>::type>::type)
+  spawn(const basic_yield_context<Executor>& ctx, allocator_arg_t,
+      BOOST_ASIO_MOVE_ARG(StackAllocator) stack_allocator,
+      BOOST_ASIO_MOVE_ARG(F) function,
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type = 0)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<CompletionToken,
+      typename detail::spawn_signature<
+        typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
+          declval<detail::initiate_spawn<Executor> >(),
+          token, allocator_arg_t(),
+          BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
+          BOOST_ASIO_MOVE_CAST(F)(function))));
+
+#endif // defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#if defined(BOOST_ASIO_HAS_BOOST_COROUTINE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// (Deprecated: Use overloads with a completion token.) Start a new stackful
+/// coroutine, calling the specified handler when it completes.
 /**
  * This function is used to launch a new coroutine.
  *
  * @param function The coroutine function. The function must have the signature:
- * @code void function(basic_yield_context<Handler> yield); @endcode
+ * @code void function(basic_yield_context<Executor> yield); @endcode
+ * where Executor is the associated executor type of @c Function.
  *
  * @param attributes Boost.Coroutine attributes used to customise the coroutine.
  */
@@ -208,8 +648,8 @@ void spawn(BOOST_ASIO_MOVE_ARG(Function) function,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes());
 
-/// Start a new stackful coroutine, calling the specified handler when it
-/// completes.
+/// (Deprecated: Use overloads with a completion token.) Start a new stackful
+/// coroutine, calling the specified handler when it completes.
 /**
  * This function is used to launch a new coroutine.
  *
@@ -219,7 +659,8 @@ void spawn(BOOST_ASIO_MOVE_ARG(Function) function,
  * @code void handler(); @endcode
  *
  * @param function The coroutine function. The function must have the signature:
- * @code void function(basic_yield_context<Handler> yield); @endcode
+ * @code void function(basic_yield_context<Executor> yield); @endcode
+ * where Executor is the associated executor type of @c Handler.
  *
  * @param attributes Boost.Coroutine attributes used to customise the coroutine.
  */
@@ -233,7 +674,8 @@ void spawn(BOOST_ASIO_MOVE_ARG(Handler) handler,
       !execution::is_executor<typename decay<Handler>::type>::value &&
       !is_convertible<Handler&, execution_context&>::value>::type = 0);
 
-/// Start a new stackful coroutine, inheriting the execution context of another.
+/// (Deprecated: Use overloads with a completion token.) Start a new stackful
+/// coroutine, inheriting the execution context of another.
 /**
  * This function is used to launch a new coroutine.
  *
@@ -244,22 +686,24 @@ void spawn(BOOST_ASIO_MOVE_ARG(Handler) handler,
  * same strand.
  *
  * @param function The coroutine function. The function must have the signature:
- * @code void function(basic_yield_context<Handler> yield); @endcode
+ * @code void function(basic_yield_context<Executor> yield); @endcode
  *
  * @param attributes Boost.Coroutine attributes used to customise the coroutine.
  */
-template <typename Handler, typename Function>
-void spawn(basic_yield_context<Handler> ctx,
+template <typename Executor, typename Function>
+void spawn(basic_yield_context<Executor> ctx,
     BOOST_ASIO_MOVE_ARG(Function) function,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes());
 
-/// Start a new stackful coroutine that executes on a given executor.
+/// (Deprecated: Use overloads with a completion token.) Start a new stackful
+/// coroutine that executes on a given executor.
 /**
  * This function is used to launch a new coroutine.
  *
  * @param ex Identifies the executor that will run the coroutine. The new
- * coroutine is implicitly given its own strand within this executor.
+ * coroutine is automatically given its own explicit strand within this
+ * executor.
  *
  * @param function The coroutine function. The function must have the signature:
  * @code void function(yield_context yield); @endcode
@@ -275,7 +719,8 @@ void spawn(const Executor& ex,
       is_executor<Executor>::value || execution::is_executor<Executor>::value
     >::type = 0);
 
-/// Start a new stackful coroutine that executes on a given strand.
+/// (Deprecated: Use overloads with a completion token.) Start a new stackful
+/// coroutine that executes on a given strand.
 /**
  * This function is used to launch a new coroutine.
  *
@@ -294,7 +739,8 @@ void spawn(const strand<Executor>& ex,
 
 #if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 
-/// Start a new stackful coroutine that executes in the context of a strand.
+/// (Deprecated: Use overloads with a completion token.) Start a new stackful
+/// coroutine that executes in the context of a strand.
 /**
  * This function is used to launch a new coroutine.
  *
@@ -315,7 +761,8 @@ void spawn(const boost::asio::io_context::strand& s,
 
 #endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 
-/// Start a new stackful coroutine that executes on a given execution context.
+/// (Deprecated: Use overloads with a completion token.) Start a new stackful
+/// coroutine that executes on a given execution context.
 /**
  * This function is used to launch a new coroutine.
  *
@@ -336,6 +783,9 @@ void spawn(ExecutionContext& ctx,
     typename constraint<is_convertible<
       ExecutionContext&, execution_context&>::value>::type = 0);
 
+#endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
 /*@}*/
 
 } // namespace asio