passenger 6.0.19 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/spawn.hpp

@@ -2,7 +2,7 @@
 // impl/spawn.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 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)
@@ -16,6 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <tuple>
 #include <boost/asio/associated_allocator.hpp>
 #include <boost/asio/associated_cancellation_slot.hpp>
 #include <boost/asio/associated_executor.hpp>
@@ -23,20 +24,13 @@
 #include <boost/asio/bind_executor.hpp>
 #include <boost/asio/detail/atomic_count.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
-#include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
-#include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/memory.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/detail/utility.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)
@@ -77,14 +71,14 @@ public:
   }
 
   template <typename F>
-  static spawned_thread_base* spawn(BOOST_ASIO_MOVE_ARG(F) f,
+  static spawned_thread_base* spawn(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);
+    callee_type callee(entry_point<decay_t<F>>(
+          static_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;
@@ -92,11 +86,11 @@ public:
   }
 
   template <typename F>
-  static spawned_thread_base* spawn(BOOST_ASIO_MOVE_ARG(F) f,
+  static spawned_thread_base* spawn(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(),
+    return spawn(static_cast<F&&>(f), boost::coroutines::attributes(),
         parent_cancel_slot, cancel_state);
   }
 
@@ -137,16 +131,16 @@ private:
   {
   public:
     template <typename F>
-    entry_point(BOOST_ASIO_MOVE_ARG(F) f,
+    entry_point(F&& f,
         spawned_coroutine_thread** spawned_thread_out)
-      : function_(BOOST_ASIO_MOVE_CAST(F)(f)),
+      : function_(static_cast<F&&>(f)),
         spawned_thread_out_(spawned_thread_out)
     {
     }
 
     void operator()(caller_type& caller)
     {
-      Function function(BOOST_ASIO_MOVE_CAST(Function)(function_));
+      Function function(static_cast<Function&&>(function_));
       spawned_coroutine_thread spawned_thread(caller);
       *spawned_thread_out_ = &spawned_thread;
       spawned_thread_out_ = 0;
@@ -194,8 +188,8 @@ 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)),
+  spawned_fiber_thread(fiber_type&& caller)
+    : caller_(static_cast<fiber_type&&>(caller)),
       on_suspend_fn_(0),
       on_suspend_arg_(0)
   {
@@ -203,35 +197,35 @@ public:
 
   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,
+      StackAllocator&& stack_allocator,
+      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 = fiber_type(BOOST_ASIO_MOVE_CAST(fiber_type)(callee)).resume();
-    spawned_thread->callee_ = BOOST_ASIO_MOVE_CAST(fiber_type)(callee);
+        static_cast<StackAllocator&&>(stack_allocator),
+        entry_point<decay_t<F>>(
+          static_cast<F&&>(f), &spawned_thread));
+    callee = fiber_type(static_cast<fiber_type&&>(callee)).resume();
+    spawned_thread->callee_ = static_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,
+  static spawned_thread_base* spawn(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);
+        static_cast<F&&>(f), parent_cancel_slot, cancel_state);
   }
 
   void resume()
   {
-    callee_ = fiber_type(BOOST_ASIO_MOVE_CAST(fiber_type)(callee_)).resume();
+    callee_ = fiber_type(static_cast<fiber_type&&>(callee_)).resume();
     if (on_suspend_fn_)
     {
       void (*fn)(void*) = on_suspend_fn_;
@@ -249,14 +243,14 @@ public:
     has_context_switched_ = true;
     on_suspend_fn_ = fn;
     on_suspend_arg_ = arg;
-    caller_ = fiber_type(BOOST_ASIO_MOVE_CAST(fiber_type)(caller_)).resume();
+    caller_ = fiber_type(static_cast<fiber_type&&>(caller_)).resume();
   }
 
   void destroy()
   {
-    fiber_type callee = BOOST_ASIO_MOVE_CAST(fiber_type)(callee_);
+    fiber_type callee = static_cast<fiber_type&&>(callee_);
     if (terminal_)
-      fiber_type(BOOST_ASIO_MOVE_CAST(fiber_type)(callee)).resume();
+      fiber_type(static_cast<fiber_type&&>(callee)).resume();
   }
 
 private:
@@ -265,18 +259,18 @@ private:
   {
   public:
     template <typename F>
-    entry_point(BOOST_ASIO_MOVE_ARG(F) f,
+    entry_point(F&& f,
         spawned_fiber_thread** spawned_thread_out)
-      : function_(BOOST_ASIO_MOVE_CAST(F)(f)),
+      : function_(static_cast<F&&>(f)),
         spawned_thread_out_(spawned_thread_out)
     {
     }
 
-    fiber_type operator()(BOOST_ASIO_MOVE_ARG(fiber_type) caller)
+    fiber_type operator()(fiber_type&& caller)
     {
-      Function function(BOOST_ASIO_MOVE_CAST(Function)(function_));
+      Function function(static_cast<Function&&>(function_));
       spawned_fiber_thread spawned_thread(
-          BOOST_ASIO_MOVE_CAST(fiber_type)(caller));
+          static_cast<fiber_type&&>(caller));
       *spawned_thread_out_ = &spawned_thread;
       spawned_thread_out_ = 0;
       spawned_thread.suspend();
@@ -300,7 +294,7 @@ private:
         spawned_thread.suspend_with(spawned_thread_rethrow, &ex);
       }
 #endif // !defined(BOOST_ASIO_NO_EXCEPTIONS)
-      return BOOST_ASIO_MOVE_CAST(fiber_type)(spawned_thread.caller_);
+      return static_cast<fiber_type&&>(spawned_thread.caller_);
     }
 
   private:
@@ -331,32 +325,14 @@ public:
   explicit spawned_thread_resumer(spawned_thread_base* spawned_thread)
     : spawned_thread_(spawned_thread)
   {
-#if !defined(BOOST_ASIO_HAS_MOVE)
-    spawned_thread->detach();
-    spawned_thread->attach(&spawned_thread_);
-#endif // !defined(BOOST_ASIO_HAS_MOVE)
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-
-  spawned_thread_resumer(spawned_thread_resumer&& other) BOOST_ASIO_NOEXCEPT
+  spawned_thread_resumer(spawned_thread_resumer&& other) noexcept
     : spawned_thread_(other.spawned_thread_)
   {
     other.spawned_thread_ = 0;
   }
 
-#else // defined(BOOST_ASIO_HAS_MOVE)
-
-  spawned_thread_resumer(
-      const spawned_thread_resumer& 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_resumer()
   {
     if (spawned_thread_)
@@ -365,9 +341,7 @@ public:
 
   void operator()()
   {
-#if defined(BOOST_ASIO_HAS_MOVE)
     spawned_thread_->attach(&spawned_thread_);
-#endif // defined(BOOST_ASIO_HAS_MOVE)
     spawned_thread_->resume();
   }
 
@@ -383,31 +357,14 @@ public:
     : 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_destroyer(spawned_thread_destroyer&& other) 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_)
@@ -440,14 +397,9 @@ public:
       spawned_thread_(yield.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)
-
-  spawn_handler_base(spawn_handler_base&& other) BOOST_ASIO_NOEXCEPT
+  spawn_handler_base(spawn_handler_base&& other) noexcept
     : yield_(other.yield_),
       spawned_thread_(other.spawned_thread_)
 
@@ -455,30 +407,18 @@ public:
     other.spawned_thread_ = 0;
   }
 
-#else // defined(BOOST_ASIO_HAS_MOVE)
-
-  spawn_handler_base(const spawn_handler_base& other) BOOST_ASIO_NOEXCEPT
-    : yield_(other.yield_),
-      spawned_thread_(other.spawned_thread_)
-  {
-    spawned_thread_->detach();
-    spawned_thread_->attach(&spawned_thread_);
-  }
-
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
   ~spawn_handler_base()
   {
     if (spawned_thread_)
       (post)(yield_.executor_, spawned_thread_destroyer(spawned_thread_));
   }
 
-  executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+  executor_type get_executor() const noexcept
   {
     return yield_.executor_;
   }
 
-  cancellation_slot_type get_cancellation_slot() const BOOST_ASIO_NOEXCEPT
+  cancellation_slot_type get_cancellation_slot() const noexcept
   {
     return spawned_thread_->get_cancellation_slot();
   }
@@ -581,7 +521,7 @@ public:
 
   static return_type on_resume(result_type& result)
   {
-    if (result)
+    if (*result)
       rethrow_exception(*result);
   }
 
@@ -611,7 +551,7 @@ public:
 
   static return_type on_resume(result_type& result)
   {
-    return BOOST_ASIO_MOVE_CAST(return_type)(*result);
+    return static_cast<return_type&&>(*result);
   }
 
 private:
@@ -654,7 +594,7 @@ public:
   {
     if (result.ec_)
       throw_error(*result.ec_);
-    return BOOST_ASIO_MOVE_CAST(return_type)(*result.value_);
+    return static_cast<return_type&&>(*result.value_);
   }
 
 private:
@@ -670,7 +610,7 @@ public:
 
   struct result_type
   {
-    exception_ptr ex_;
+    exception_ptr* ex_;
     return_type* value_;
   };
 
@@ -689,18 +629,15 @@ public:
 
   static return_type on_resume(result_type& result)
   {
-    if (result.ex_)
+    if (*result.ex_)
       rethrow_exception(*result.ex_);
-    return BOOST_ASIO_MOVE_CAST(return_type)(*result.value_);
+    return static_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>
@@ -717,16 +654,16 @@ public:
   }
 
   template <typename... Args>
-  void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
+  void operator()(Args&&... args)
   {
-    return_type value(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    return_type value(static_cast<Args&&>(args)...);
     result_ = &value;
     this->resume();
   }
 
   static return_type on_resume(result_type& result)
   {
-    return BOOST_ASIO_MOVE_CAST(return_type)(*result);
+    return static_cast<return_type&&>(*result);
   }
 
 private:
@@ -754,9 +691,9 @@ public:
 
   template <typename... Args>
   void operator()(boost::system::error_code ec,
-      BOOST_ASIO_MOVE_ARG(Args)... args)
+      Args&&... args)
   {
-    return_type value(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    return_type value(static_cast<Args&&>(args)...);
     if (this->yield_.ec_)
     {
       *this->yield_.ec_ = ec;
@@ -772,7 +709,7 @@ public:
   {
     if (result.ec_)
       throw_error(*result.ec_);
-    return BOOST_ASIO_MOVE_CAST(return_type)(*result.value_);
+    return static_cast<return_type&&>(*result.value_);
   }
 
 private:
@@ -788,7 +725,7 @@ public:
 
   struct result_type
   {
-    exception_ptr ex_;
+    exception_ptr* ex_;
     return_type* value_;
   };
 
@@ -799,9 +736,9 @@ public:
   }
 
   template <typename... Args>
-  void operator()(exception_ptr ex, BOOST_ASIO_MOVE_ARG(Args)... args)
+  void operator()(exception_ptr ex, Args&&... args)
   {
-    return_type value(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    return_type value(static_cast<Args&&>(args)...);
     result_.ex_ = &ex;
     result_.value_ = &value;
     this->resume();
@@ -809,18 +746,15 @@ public:
 
   static return_type on_resume(result_type& result)
   {
-    if (result.ex_)
+    if (*result.ex_)
       rethrow_exception(*result.ex_);
-    return BOOST_ASIO_MOVE_CAST(return_type)(*result.value_);
+    return static_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>*)
 {
@@ -836,13 +770,12 @@ public:
   typedef typename detail::spawn_handler<Executor, Signature> handler_type;
   typedef typename handler_type::return_type return_type;
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-# if defined(BOOST_ASIO_HAS_VARIADIC_LAMBDA_CAPTURES)
+#if defined(BOOST_ASIO_HAS_VARIADIC_LAMBDA_CAPTURES)
 
   template <typename Initiation, typename... InitArgs>
-  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation) init,
+  static return_type initiate(Initiation&& init,
       const basic_yield_context<Executor>& yield,
-      BOOST_ASIO_MOVE_ARG(InitArgs)... init_args)
+      InitArgs&&... init_args)
   {
     typename handler_type::result_type result
       = typename handler_type::result_type();
@@ -850,30 +783,30 @@ public:
     yield.spawned_thread_->suspend_with(
         [&]()
         {
-          BOOST_ASIO_MOVE_CAST(Initiation)(init)(
+          static_cast<Initiation&&>(init)(
               handler_type(yield, result),
-              BOOST_ASIO_MOVE_CAST(InitArgs)(init_args)...);
+              static_cast<InitArgs&&>(init_args)...);
         });
 
     return handler_type::on_resume(result);
   }
 
-# else // defined(BOOST_ASIO_HAS_VARIADIC_LAMBDA_CAPTURES)
+#else // defined(BOOST_ASIO_HAS_VARIADIC_LAMBDA_CAPTURES)
 
   template <typename Initiation, typename... InitArgs>
   struct suspend_with_helper
   {
     typename handler_type::result_type& result_;
-    BOOST_ASIO_MOVE_ARG(Initiation) init_;
+    Initiation&& init_;
     const basic_yield_context<Executor>& yield_;
-    std::tuple<BOOST_ASIO_MOVE_ARG(InitArgs)...> init_args_;
+    std::tuple<InitArgs&&...> init_args_;
 
     template <std::size_t... I>
     void do_invoke(detail::index_sequence<I...>)
     {
-      BOOST_ASIO_MOVE_CAST(Initiation)(init_)(
+      static_cast<Initiation&&>(init_)(
           handler_type(yield_, result_),
-          BOOST_ASIO_MOVE_CAST(InitArgs)(std::get<I>(init_args_))...);
+          static_cast<InitArgs&&>(std::get<I>(init_args_))...);
     }
 
     void operator()()
@@ -883,121 +816,23 @@ public:
   };
 
   template <typename Initiation, typename... InitArgs>
-  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation) init,
+  static return_type initiate(Initiation&& init,
       const basic_yield_context<Executor>& yield,
-      BOOST_ASIO_MOVE_ARG(InitArgs)... init_args)
+      InitArgs&&... init_args)
   {
     typename handler_type::result_type result
       = typename handler_type::result_type();
 
     yield.spawned_thread_->suspend_with(
       suspend_with_helper<Initiation, InitArgs...>{
-          result, BOOST_ASIO_MOVE_CAST(Initiation)(init), yield,
-          std::tuple<BOOST_ASIO_MOVE_ARG(InitArgs)...>(
-            BOOST_ASIO_MOVE_CAST(InitArgs)(init_args)...)});
-
-    return handler_type::on_resume(result);
-  }
-
-# endif // defined(BOOST_ASIO_HAS_VARIADIC_LAMBDA_CAPTURES)
-#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);
+          result, static_cast<Initiation&&>(init), yield,
+          std::tuple<InitArgs&&...>(
+            static_cast<InitArgs&&>(init_args)...)});
 
     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)
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_LAMBDA_CAPTURES)
 };
 
 namespace detail {
@@ -1008,10 +843,10 @@ 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)
+      F&& f, H&& h)
     : executor_(ex),
-      function_(BOOST_ASIO_MOVE_CAST(F)(f)),
-      handler_(BOOST_ASIO_MOVE_CAST(H)(h)),
+      function_(static_cast<F&&>(f)),
+      handler_(static_cast<H&&>(h)),
       work_(handler_, executor_)
   {
   }
@@ -1020,8 +855,7 @@ public:
   {
     const basic_yield_context<Executor> yield(spawned_thread, executor_);
     this->call(yield,
-        void_type<typename result_of<Function(
-          basic_yield_context<Executor>)>::type>());
+        void_type<result_of_t<Function(basic_yield_context<Executor>)>>());
   }
 
 private:
@@ -1073,7 +907,7 @@ private:
       if (!yield.spawned_thread_->has_context_switched())
         (post)(yield);
       detail::binder2<Handler, exception_ptr, T>
-        handler(handler_, exception_ptr(), BOOST_ASIO_MOVE_CAST(T)(result));
+        handler(handler_, exception_ptr(), static_cast<T&&>(result));
       work_.complete(handler, handler.handler_);
     }
 #if !defined(BOOST_ASIO_NO_EXCEPTIONS)
@@ -1145,13 +979,13 @@ private:
 
 template <typename Handler, typename Executor>
 class spawn_cancellation_handler<Handler, Executor,
-    typename enable_if<
+    enable_if_t<
       is_same<
         typename associated_executor<Handler,
           Executor>::asio_associated_executor_is_unspecialised,
         void
       >::value
-    >::type>
+    >>
 {
 public:
   spawn_cancellation_handler(const Handler&, const Executor&)
@@ -1183,21 +1017,21 @@ public:
   {
   }
 
-  executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+  executor_type get_executor() const noexcept
   {
     return executor_;
   }
 
   template <typename Handler, typename F>
-  void operator()(BOOST_ASIO_MOVE_ARG(Handler) handler,
-      BOOST_ASIO_MOVE_ARG(F) f) const
+  void operator()(Handler&& handler,
+      F&& f) const
   {
-    typedef typename decay<Handler>::type handler_type;
-    typedef typename decay<F>::type function_type;
+    typedef decay_t<Handler> handler_type;
+    typedef decay_t<F> function_type;
     typedef spawn_cancellation_handler<
       handler_type, Executor> cancel_handler_type;
 
-    typename associated_cancellation_slot<handler_type>::type slot
+    associated_cancellation_slot_t<handler_type> slot
       = boost::asio::get_associated_cancellation_slot(handler);
 
     cancel_handler_type* cancel_handler = slot.is_connected()
@@ -1215,24 +1049,24 @@ public:
         spawned_thread_resumer(
           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)),
+              executor_, static_cast<F&&>(f),
+              static_cast<Handler&&>(handler)),
             proxy_slot, cancel_state)));
   }
 
 #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
+  void operator()(Handler&& handler, allocator_arg_t,
+      StackAllocator&& stack_allocator,
+      F&& f) const
   {
-    typedef typename decay<Handler>::type handler_type;
-    typedef typename decay<F>::type function_type;
+    typedef decay_t<Handler> handler_type;
+    typedef decay_t<F> function_type;
     typedef spawn_cancellation_handler<
       handler_type, Executor> cancel_handler_type;
 
-    typename associated_cancellation_slot<handler_type>::type slot
+    associated_cancellation_slot_t<handler_type> slot
       = boost::asio::get_associated_cancellation_slot(handler);
 
     cancel_handler_type* cancel_handler = slot.is_connected()
@@ -1249,10 +1083,10 @@ public:
     (dispatch)(executor_,
         spawned_thread_resumer(
           spawned_fiber_thread::spawn(allocator_arg_t(),
-            BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
+            static_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)),
+              executor_, static_cast<F&&>(f),
+              static_cast<Handler&&>(handler)),
             proxy_slot, cancel_state)));
   }
 
@@ -1266,198 +1100,162 @@ private:
 
 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,
+      result_of_t<F(basic_yield_context<Executor>)>>::type) CompletionToken>
+inline auto spawn(const Executor& ex, F&& function, CompletionToken&& token,
 #if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
-    typename constraint<
+    constraint_t<
       !is_same<
-        typename decay<CompletionToken>::type,
+        decay_t<CompletionToken>,
         boost::coroutines::attributes
       >::value
-    >::type,
+    >,
 #endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
-    typename constraint<
+    constraint_t<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >::type)
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    >)
+  -> decltype(
     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))))
+        result_of_t<F(basic_yield_context<Executor>)>>::type>(
+          declval<detail::initiate_spawn<Executor>>(),
+          token, static_cast<F&&>(function)))
 {
   return async_initiate<CompletionToken,
     typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
+      result_of_t<F(basic_yield_context<Executor>)>>::type>(
         detail::initiate_spawn<Executor>(ex),
-        token, BOOST_ASIO_MOVE_CAST(F)(function));
+        token, static_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,
+      result_of_t<F(basic_yield_context<
+        typename ExecutionContext::executor_type>)>>::type) CompletionToken>
+inline auto spawn(ExecutionContext& ctx, F&& function, CompletionToken&& token,
 #if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
-    typename constraint<
+    constraint_t<
       !is_same<
-        typename decay<CompletionToken>::type,
+        decay_t<CompletionToken>,
         boost::coroutines::attributes
       >::value
-    >::type,
+    >,
 #endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
-    typename constraint<
+    constraint_t<
       is_convertible<ExecutionContext&, execution_context&>::value
-    >::type)
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    >)
+  -> decltype(
     async_initiate<CompletionToken,
       typename detail::spawn_signature<
-        typename result_of<F(basic_yield_context<
-          typename ExecutionContext::executor_type>)>::type>::type>(
+        result_of_t<F(basic_yield_context<
+          typename ExecutionContext::executor_type>)>>::type>(
             declval<detail::initiate_spawn<
-              typename ExecutionContext::executor_type> >(),
-            token, BOOST_ASIO_MOVE_CAST(F)(function))))
+              typename ExecutionContext::executor_type>>(),
+            token, static_cast<F&&>(function)))
 {
-  return (spawn)(ctx.get_executor(), BOOST_ASIO_MOVE_CAST(F)(function),
-      BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
+  return (spawn)(ctx.get_executor(), static_cast<F&&>(function),
+      static_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)
+      result_of_t<F(basic_yield_context<Executor>)>>::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,
+inline auto spawn(const basic_yield_context<Executor>& ctx,
+    F&& function, CompletionToken&& token,
 #if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
-    typename constraint<
+    constraint_t<
       !is_same<
-        typename decay<CompletionToken>::type,
+        decay_t<CompletionToken>,
         boost::coroutines::attributes
       >::value
-    >::type,
+    >,
 #endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
-    typename constraint<
+    constraint_t<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >::type)
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    >)
+  -> decltype(
     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))))
+        result_of_t<F(basic_yield_context<Executor>)>>::type>(
+          declval<detail::initiate_spawn<Executor>>(),
+          token, static_cast<F&&>(function)))
 {
-  return (spawn)(ctx.get_executor(), BOOST_ASIO_MOVE_CAST(F)(function),
-      BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
+  return (spawn)(ctx.get_executor(), static_cast<F&&>(function),
+      static_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)
+      result_of_t<F(basic_yield_context<Executor>)>>::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<
+inline auto spawn(const Executor& ex, allocator_arg_t,
+    StackAllocator&& stack_allocator, F&& function, CompletionToken&& token,
+    constraint_t<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >::type)
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    >)
+  -> decltype(
     async_initiate<CompletionToken,
       typename detail::spawn_signature<
-        typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
-          declval<detail::initiate_spawn<Executor> >(),
+        result_of_t<F(basic_yield_context<Executor>)>>::type>(
+          declval<detail::initiate_spawn<Executor>>(),
           token, allocator_arg_t(),
-          BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
-          BOOST_ASIO_MOVE_CAST(F)(function))))
+          static_cast<StackAllocator&&>(stack_allocator),
+          static_cast<F&&>(function)))
 {
   return async_initiate<CompletionToken,
     typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
+      result_of_t<F(basic_yield_context<Executor>)>>::type>(
         detail::initiate_spawn<Executor>(ex), token, allocator_arg_t(),
-        BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
-        BOOST_ASIO_MOVE_CAST(F)(function));
+        static_cast<StackAllocator&&>(stack_allocator),
+        static_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<
+      result_of_t<F(basic_yield_context<
+        typename ExecutionContext::executor_type>)>>::type) CompletionToken>
+inline auto spawn(ExecutionContext& ctx, allocator_arg_t,
+    StackAllocator&& stack_allocator, F&& function, CompletionToken&& token,
+    constraint_t<
       is_convertible<ExecutionContext&, execution_context&>::value
-    >::type)
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    >)
+  -> decltype(
     async_initiate<CompletionToken,
       typename detail::spawn_signature<
-        typename result_of<F(basic_yield_context<
-          typename ExecutionContext::executor_type>)>::type>::type>(
+        result_of_t<F(basic_yield_context<
+          typename ExecutionContext::executor_type>)>>::type>(
             declval<detail::initiate_spawn<
-              typename ExecutionContext::executor_type> >(),
+              typename ExecutionContext::executor_type>>(),
             token, allocator_arg_t(),
-            BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
-            BOOST_ASIO_MOVE_CAST(F)(function))))
+            static_cast<StackAllocator&&>(stack_allocator),
+            static_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));
+      static_cast<StackAllocator&&>(stack_allocator),
+      static_cast<F&&>(function), static_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<
+      result_of_t<F(basic_yield_context<Executor>)>>::type) CompletionToken>
+inline auto spawn(const basic_yield_context<Executor>& ctx, allocator_arg_t,
+    StackAllocator&& stack_allocator, F&& function, CompletionToken&& token,
+    constraint_t<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >::type)
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    >)
+  -> decltype(
     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))))
+        result_of_t<F(basic_yield_context<Executor>)>>::type>(
+          declval<detail::initiate_spawn<Executor>>(), token,
+          allocator_arg_t(), static_cast<StackAllocator&&>(stack_allocator),
+          static_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));
+      static_cast<StackAllocator&&>(stack_allocator),
+      static_cast<F&&>(function), static_cast<CompletionToken&&>(token));
 }
 
 #endif // defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
@@ -1471,11 +1269,10 @@ 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)
+  old_spawn_entry_point(const Executor& ex, F&& f, H&& h)
     : executor_(ex),
-      function_(BOOST_ASIO_MOVE_CAST(F)(f)),
-      handler_(BOOST_ASIO_MOVE_CAST(H)(h))
+      function_(static_cast<F&&>(f)),
+      handler_(static_cast<H&&>(h))
   {
   }
 
@@ -1483,21 +1280,20 @@ public:
   {
     const basic_yield_context<Executor> yield(spawned_thread, executor_);
     this->call(yield,
-        void_type<typename result_of<Function(
-          basic_yield_context<Executor>)>::type>());
+        void_type<result_of_t<Function(basic_yield_context<Executor>)>>());
   }
 
 private:
   void call(const basic_yield_context<Executor>& yield, void_type<void>)
   {
     function_(yield);
-    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)();
+    static_cast<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));
+    static_cast<Handler&&>(handler_)(function_(yield));
   }
 
   Executor executor_;
@@ -1510,102 +1306,90 @@ inline void default_spawn_handler() {}
 } // namespace detail
 
 template <typename Function>
-inline void spawn(BOOST_ASIO_MOVE_ARG(Function) function,
+inline void spawn(Function&& function,
     const boost::coroutines::attributes& attributes)
 {
-  typedef typename decay<Function>::type function_type;
-
-  typename associated_executor<function_type>::type ex(
+  associated_executor_t<decay_t<Function>> ex(
       (get_associated_executor)(function));
 
-  boost::asio::spawn(ex, BOOST_ASIO_MOVE_CAST(Function)(function), attributes);
+  boost::asio::spawn(ex, static_cast<Function&&>(function), attributes);
 }
 
 template <typename Handler, typename Function>
-void spawn(BOOST_ASIO_MOVE_ARG(Handler) handler,
-    BOOST_ASIO_MOVE_ARG(Function) function,
+void spawn(Handler&& handler, Function&& function,
     const boost::coroutines::attributes& attributes,
-    typename constraint<
-      !is_executor<typename decay<Handler>::type>::value &&
-      !execution::is_executor<typename decay<Handler>::type>::value &&
-      !is_convertible<Handler&, execution_context&>::value>::type)
+    constraint_t<
+      !is_executor<decay_t<Handler>>::value &&
+      !execution::is_executor<decay_t<Handler>>::value &&
+      !is_convertible<Handler&, execution_context&>::value>)
 {
-  typedef typename decay<Handler>::type handler_type;
-  typedef typename decay<Function>::type function_type;
-  typedef typename associated_executor<handler_type>::type executor_type;
-
+  typedef associated_executor_t<decay_t<Handler>> executor_type;
   executor_type ex((get_associated_executor)(handler));
 
   (dispatch)(ex,
       detail::spawned_thread_resumer(
         detail::spawned_coroutine_thread::spawn(
           detail::old_spawn_entry_point<executor_type,
-            function_type, void (*)()>(
-              ex, BOOST_ASIO_MOVE_CAST(Function)(function),
+            decay_t<Function>, void (*)()>(
+              ex, static_cast<Function&&>(function),
               &detail::default_spawn_handler), attributes)));
 }
 
 template <typename Executor, typename Function>
-void spawn(basic_yield_context<Executor> ctx,
-    BOOST_ASIO_MOVE_ARG(Function) function,
+void spawn(basic_yield_context<Executor> ctx, Function&& function,
     const boost::coroutines::attributes& attributes)
 {
-  typedef typename decay<Function>::type function_type;
-
   (dispatch)(ctx.get_executor(),
       detail::spawned_thread_resumer(
         detail::spawned_coroutine_thread::spawn(
           detail::old_spawn_entry_point<Executor,
-            function_type, void (*)()>(ctx.get_executor(),
-              BOOST_ASIO_MOVE_CAST(Function)(function),
+            decay_t<Function>, void (*)()>(
+              ctx.get_executor(), static_cast<Function&&>(function),
               &detail::default_spawn_handler), attributes)));
 }
 
 template <typename Function, typename Executor>
-inline void spawn(const Executor& ex,
-    BOOST_ASIO_MOVE_ARG(Function) function,
+inline void spawn(const Executor& ex, Function&& function,
     const boost::coroutines::attributes& attributes,
-    typename constraint<
+    constraint_t<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >::type)
+    >)
 {
   boost::asio::spawn(boost::asio::strand<Executor>(ex),
-      BOOST_ASIO_MOVE_CAST(Function)(function), attributes);
+      static_cast<Function&&>(function), attributes);
 }
 
 template <typename Function, typename Executor>
-inline void spawn(const strand<Executor>& ex,
-    BOOST_ASIO_MOVE_ARG(Function) function,
+inline void spawn(const strand<Executor>& ex, Function&& function,
     const boost::coroutines::attributes& attributes)
 {
   boost::asio::spawn(boost::asio::bind_executor(
         ex, &detail::default_spawn_handler),
-      BOOST_ASIO_MOVE_CAST(Function)(function), attributes);
+      static_cast<Function&&>(function), attributes);
 }
 
 #if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 
 template <typename Function>
-inline void spawn(const boost::asio::io_context::strand& s,
-    BOOST_ASIO_MOVE_ARG(Function) function,
+inline void spawn(const boost::asio::io_context::strand& s, Function&& function,
     const boost::coroutines::attributes& attributes)
 {
   boost::asio::spawn(boost::asio::bind_executor(
         s, &detail::default_spawn_handler),
-      BOOST_ASIO_MOVE_CAST(Function)(function), attributes);
+      static_cast<Function&&>(function), attributes);
 }
 
 #endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 
 template <typename Function, typename ExecutionContext>
-inline void spawn(ExecutionContext& ctx,
-    BOOST_ASIO_MOVE_ARG(Function) function,
+inline void spawn(ExecutionContext& ctx, Function&& function,
     const boost::coroutines::attributes& attributes,
-    typename constraint<is_convertible<
-      ExecutionContext&, execution_context&>::value>::type)
+    constraint_t<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    >)
 {
   boost::asio::spawn(ctx.get_executor(),
-      BOOST_ASIO_MOVE_CAST(Function)(function), attributes);
+      static_cast<Function&&>(function), attributes);
 }
 
 #endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)