passenger 6.0.19 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/asio/async_result.hpp

@@ -2,7 +2,7 @@
 // async_result.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)
@@ -17,16 +17,13 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/detail/type_traits.hpp>
-#include <boost/asio/detail/variadic_templates.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
-#if defined(BOOST_ASIO_HAS_CONCEPTS) \
-  && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) \
-  && defined(BOOST_ASIO_HAS_DECLTYPE)
+#if defined(BOOST_ASIO_HAS_CONCEPTS)
 
 namespace detail {
 
@@ -40,8 +37,6 @@ struct is_completion_signature<R(Args...)> : true_type
 {
 };
 
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
-
 template <typename R, typename... Args>
 struct is_completion_signature<R(Args...) &> : true_type
 {
@@ -70,7 +65,6 @@ struct is_completion_signature<R(Args...) && noexcept> : true_type
 };
 
 # endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
 
 template <typename... T>
 struct are_completion_signatures : false_type
@@ -104,21 +98,19 @@ struct is_completion_handler_for : false_type
 
 template <typename T, typename R, typename... Args>
 struct is_completion_handler_for<T, R(Args...)>
-  : integral_constant<bool, (callable_with<T, Args...>)>
+  : integral_constant<bool, (callable_with<decay_t<T>, Args...>)>
 {
 };
 
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
-
 template <typename T, typename R, typename... Args>
 struct is_completion_handler_for<T, R(Args...) &>
-  : integral_constant<bool, (callable_with<T&, Args...>)>
+  : integral_constant<bool, (callable_with<decay_t<T>&, Args...>)>
 {
 };
 
 template <typename T, typename R, typename... Args>
 struct is_completion_handler_for<T, R(Args...) &&>
-  : integral_constant<bool, (callable_with<T&&, Args...>)>
+  : integral_constant<bool, (callable_with<decay_t<T>&&, Args...>)>
 {
 };
 
@@ -126,24 +118,23 @@ struct is_completion_handler_for<T, R(Args...) &&>
 
 template <typename T, typename R, typename... Args>
 struct is_completion_handler_for<T, R(Args...) noexcept>
-  : integral_constant<bool, (callable_with<T, Args...>)>
+  : integral_constant<bool, (callable_with<decay_t<T>, Args...>)>
 {
 };
 
 template <typename T, typename R, typename... Args>
 struct is_completion_handler_for<T, R(Args...) & noexcept>
-  : integral_constant<bool, (callable_with<T&, Args...>)>
+  : integral_constant<bool, (callable_with<decay_t<T>&, Args...>)>
 {
 };
 
 template <typename T, typename R, typename... Args>
 struct is_completion_handler_for<T, R(Args...) && noexcept>
-  : integral_constant<bool, (callable_with<T&&, Args...>)>
+  : integral_constant<bool, (callable_with<decay_t<T>&&, Args...>)>
 {
 };
 
 # endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
 
 template <typename T, typename Signature0, typename... SignatureN>
 struct is_completion_handler_for<T, Signature0, SignatureN...>
@@ -175,8 +166,6 @@ BOOST_ASIO_CONCEPT completion_handler_for =
   ::boost::asio::completion_handler_for<sig0, sig1, sig2>
 
 #else // defined(BOOST_ASIO_HAS_CONCEPTS)
-      //   && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-      //   && defined(BOOST_ASIO_HAS_DECLTYPE)
 
 #define BOOST_ASIO_COMPLETION_SIGNATURE typename
 #define BOOST_ASIO_COMPLETION_HANDLER_FOR(sig) typename
@@ -184,277 +173,130 @@ BOOST_ASIO_CONCEPT completion_handler_for =
 #define BOOST_ASIO_COMPLETION_HANDLER_FOR3(sig0, sig1, sig2) typename
 
 #endif // defined(BOOST_ASIO_HAS_CONCEPTS)
-       //   && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-       //   && defined(BOOST_ASIO_HAS_DECLTYPE)
 
 namespace detail {
 
 template <typename T>
-struct is_simple_completion_signature : false_type
+struct is_lvalue_completion_signature : false_type
 {
 };
 
-template <typename T>
-struct simple_completion_signature;
+template <typename R, typename... Args>
+struct is_lvalue_completion_signature<R(Args...) &> : true_type
+{
+};
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+# if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
 
 template <typename R, typename... Args>
-struct is_simple_completion_signature<R(Args...)> : true_type
+struct is_lvalue_completion_signature<R(Args...) & noexcept> : true_type
 {
 };
 
+# endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
 template <typename... Signatures>
-struct are_simple_completion_signatures : false_type
+struct are_any_lvalue_completion_signatures : false_type
 {
 };
 
 template <typename Sig0>
-struct are_simple_completion_signatures<Sig0>
-  : is_simple_completion_signature<Sig0>
+struct are_any_lvalue_completion_signatures<Sig0>
+  : is_lvalue_completion_signature<Sig0>
 {
 };
 
 template <typename Sig0, typename... SigN>
-struct are_simple_completion_signatures<Sig0, SigN...>
+struct are_any_lvalue_completion_signatures<Sig0, SigN...>
   : integral_constant<bool, (
-      is_simple_completion_signature<Sig0>::value
-        && are_simple_completion_signatures<SigN...>::value)>
-{
-};
-
-template <typename R, typename... Args>
-struct simple_completion_signature<R(Args...)>
+      is_lvalue_completion_signature<Sig0>::value
+        || are_any_lvalue_completion_signatures<SigN...>::value)>
 {
-  typedef R type(Args...);
 };
 
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
-
-template <typename R, typename... Args>
-struct simple_completion_signature<R(Args...) &>
+template <typename T>
+struct is_rvalue_completion_signature : false_type
 {
-  typedef R type(Args...);
 };
 
 template <typename R, typename... Args>
-struct simple_completion_signature<R(Args...) &&>
+struct is_rvalue_completion_signature<R(Args...) &&> : true_type
 {
-  typedef R type(Args...);
 };
 
 # if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
 
 template <typename R, typename... Args>
-struct simple_completion_signature<R(Args...) noexcept>
+struct is_rvalue_completion_signature<R(Args...) && noexcept> : true_type
 {
-  typedef R type(Args...);
-};
-
-template <typename R, typename... Args>
-struct simple_completion_signature<R(Args...) & noexcept>
-{
-  typedef R type(Args...);
-};
-
-template <typename R, typename... Args>
-struct simple_completion_signature<R(Args...) && noexcept>
-{
-  typedef R type(Args...);
 };
 
 # endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-template <typename R>
-struct is_simple_completion_signature<R()> : true_type
-{
-};
-
-#define BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF(n) \
-  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct is_simple_completion_signature<R(BOOST_ASIO_VARIADIC_TARGS(n))> \
-    : true_type \
-  { \
-  }; \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF)
-#undef BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF
-
-template <typename Sig0 = void, typename Sig1 = void,
-    typename Sig2 = void, typename = void>
-struct are_simple_completion_signatures : false_type
+template <typename... Signatures>
+struct are_any_rvalue_completion_signatures : false_type
 {
 };
 
 template <typename Sig0>
-struct are_simple_completion_signatures<Sig0>
-  : is_simple_completion_signature<Sig0>
+struct are_any_rvalue_completion_signatures<Sig0>
+  : is_rvalue_completion_signature<Sig0>
 {
 };
 
-template <typename Sig0, typename Sig1>
-struct are_simple_completion_signatures<Sig0, Sig1>
-  : integral_constant<bool,
-      (is_simple_completion_signature<Sig0>::value
-        && is_simple_completion_signature<Sig1>::value)>
-{
-};
-
-template <typename Sig0, typename Sig1, typename Sig2>
-struct are_simple_completion_signatures<Sig0, Sig1, Sig2>
-  : integral_constant<bool,
-      (is_simple_completion_signature<Sig0>::value
-        && is_simple_completion_signature<Sig1>::value
-        && is_simple_completion_signature<Sig2>::value)>
+template <typename Sig0, typename... SigN>
+struct are_any_rvalue_completion_signatures<Sig0, SigN...>
+  : integral_constant<bool, (
+      is_rvalue_completion_signature<Sig0>::value
+        || are_any_rvalue_completion_signatures<SigN...>::value)>
 {
 };
 
-template <>
-struct simple_completion_signature<void>
-{
-  typedef void type;
-};
+template <typename T>
+struct simple_completion_signature;
 
-template <typename R>
-struct simple_completion_signature<R()>
+template <typename R, typename... Args>
+struct simple_completion_signature<R(Args...)>
 {
-  typedef R type();
+  typedef R type(Args...);
 };
 
-#define BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF(n) \
-  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct simple_completion_signature<R(BOOST_ASIO_VARIADIC_TARGS(n))> \
-  { \
-    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)); \
-  }; \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF)
-#undef BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF
-
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
-
-template <typename R>
-struct simple_completion_signature<R() &>
+template <typename R, typename... Args>
+struct simple_completion_signature<R(Args...) &>
 {
-  typedef R type();
+  typedef R type(Args...);
 };
 
-template <typename R>
-struct simple_completion_signature<R() &&>
+template <typename R, typename... Args>
+struct simple_completion_signature<R(Args...) &&>
 {
-  typedef R type();
+  typedef R type(Args...);
 };
 
-#define BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF(n) \
-  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct simple_completion_signature< \
-    R(BOOST_ASIO_VARIADIC_TARGS(n)) &> \
-  { \
-    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)); \
-  }; \
-  \
-  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct simple_completion_signature< \
-    R(BOOST_ASIO_VARIADIC_TARGS(n)) &&> \
-  { \
-    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)); \
-  }; \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF)
-#undef BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF
-
 # if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
 
-template <typename R>
-struct simple_completion_signature<R() noexcept>
+template <typename R, typename... Args>
+struct simple_completion_signature<R(Args...) noexcept>
 {
-  typedef R type();
+  typedef R type(Args...);
 };
 
-template <typename R>
-struct simple_completion_signature<R() & noexcept>
+template <typename R, typename... Args>
+struct simple_completion_signature<R(Args...) & noexcept>
 {
-  typedef R type();
+  typedef R type(Args...);
 };
 
-template <typename R>
-struct simple_completion_signature<R() && noexcept>
+template <typename R, typename... Args>
+struct simple_completion_signature<R(Args...) && noexcept>
 {
-  typedef R type();
+  typedef R type(Args...);
 };
 
-#define BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF(n) \
-  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct simple_completion_signature< \
-    R(BOOST_ASIO_VARIADIC_TARGS(n)) noexcept> \
-  { \
-    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)); \
-  }; \
-  \
-  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct simple_completion_signature< \
-    R(BOOST_ASIO_VARIADIC_TARGS(n)) & noexcept> \
-  { \
-    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)); \
-  }; \
-  \
-  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct simple_completion_signature< \
-    R(BOOST_ASIO_VARIADIC_TARGS(n)) && noexcept> \
-  { \
-    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)); \
-  }; \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF)
-#undef BOOST_ASIO_PRIVATE_SIMPLE_SIG_DEF
-
 # endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) \
-  || defined(GENERATING_DOCUMENTATION)
-
-# define BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS \
-    BOOST_ASIO_COMPLETION_SIGNATURE... Signatures
-
-# define BOOST_ASIO_COMPLETION_SIGNATURES_TSPECPARAMS \
-    BOOST_ASIO_COMPLETION_SIGNATURE... Signatures
-
-# define BOOST_ASIO_COMPLETION_SIGNATURES_TARGS Signatures...
-
-# define BOOST_ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS \
-    typename boost::asio::detail::simple_completion_signature< \
-      Signatures>::type...
-
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-      //   || defined(GENERATING_DOCUMENTATION)
-
-# define BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS \
-    typename Sig0 = void, \
-    typename Sig1 = void, \
-    typename Sig2 = void
 
-# define BOOST_ASIO_COMPLETION_SIGNATURES_TSPECPARAMS \
-    typename Sig0, \
-    typename Sig1, \
-    typename Sig2
-
-# define BOOST_ASIO_COMPLETION_SIGNATURES_TARGS Sig0, Sig1, Sig2
-
-# define BOOST_ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS \
-    typename ::boost::asio::detail::simple_completion_signature<Sig0>::type, \
-    typename ::boost::asio::detail::simple_completion_signature<Sig1>::type, \
-    typename ::boost::asio::detail::simple_completion_signature<Sig2>::type
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
+template <typename CompletionToken,
+    BOOST_ASIO_COMPLETION_SIGNATURE... Signatures>
 class completion_handler_async_result
 {
 public:
@@ -469,56 +311,22 @@ public:
   {
   }
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
   template <typename Initiation,
       BOOST_ASIO_COMPLETION_HANDLER_FOR(Signatures...) RawCompletionToken,
       typename... Args>
-  static return_type initiate(
-      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
-      BOOST_ASIO_MOVE_ARG(Args)... args)
+  static return_type initiate(Initiation&& initiation,
+      RawCompletionToken&& token, Args&&... args)
   {
-    BOOST_ASIO_MOVE_CAST(Initiation)(initiation)(
-        BOOST_ASIO_MOVE_CAST(RawCompletionToken)(token),
-        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    static_cast<Initiation&&>(initiation)(
+        static_cast<RawCompletionToken&&>(token),
+        static_cast<Args&&>(args)...);
   }
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-  template <typename Initiation, typename RawCompletionToken>
-  static return_type initiate(
-      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token)
-  {
-    BOOST_ASIO_MOVE_CAST(Initiation)(initiation)(
-        BOOST_ASIO_MOVE_CAST(RawCompletionToken)(token));
-  }
-
-#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
-  template <typename Initiation, \
-      typename RawCompletionToken, \
-      BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  static return_type initiate( \
-      BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
-      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token, \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-  { \
-    BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( \
-        BOOST_ASIO_MOVE_CAST(RawCompletionToken)(token), \
-        BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF)
-#undef BOOST_ASIO_PRIVATE_INITIATE_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 private:
   completion_handler_async_result(
-      const completion_handler_async_result&) BOOST_ASIO_DELETED;
+      const completion_handler_async_result&) = delete;
   completion_handler_async_result& operator=(
-      const completion_handler_async_result&) BOOST_ASIO_DELETED;
+      const completion_handler_async_result&) = delete;
 };
 
 } // namespace detail
@@ -543,7 +351,8 @@ private:
  * The primary template assumes that the CompletionToken is the completion
  * handler.
  */
-template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
+template <typename CompletionToken,
+    BOOST_ASIO_COMPLETION_SIGNATURE... Signatures>
 class async_result
 {
 public:
@@ -568,70 +377,46 @@ public:
   /// obtain the value to be returned from the initiating function.
   template <typename Initiation, typename RawCompletionToken, typename... Args>
   static return_type initiate(
-      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
-      BOOST_ASIO_MOVE_ARG(Args)... args);
+      Initiation&& initiation,
+      RawCompletionToken&& token,
+      Args&&... args);
 
 private:
-  async_result(const async_result&) BOOST_ASIO_DELETED;
-  async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
+  async_result(const async_result&) = delete;
+  async_result& operator=(const async_result&) = delete;
 };
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
-
-template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
+template <typename CompletionToken,
+    BOOST_ASIO_COMPLETION_SIGNATURE... Signatures>
 class async_result :
-  public conditional<
-      detail::are_simple_completion_signatures<
-        BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>::value,
-      detail::completion_handler_async_result<
-        CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>,
+  public conditional_t<
+      detail::are_any_lvalue_completion_signatures<Signatures...>::value
+        || !detail::are_any_rvalue_completion_signatures<Signatures...>::value,
+      detail::completion_handler_async_result<CompletionToken, Signatures...>,
       async_result<CompletionToken,
-        BOOST_ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS>
-    >::type
+        typename detail::simple_completion_signature<Signatures>::type...>
+    >
 {
 public:
-  typedef typename conditional<
-      detail::are_simple_completion_signatures<
-        BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>::value,
-      detail::completion_handler_async_result<
-        CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>,
+  typedef conditional_t<
+      detail::are_any_lvalue_completion_signatures<Signatures...>::value
+        || !detail::are_any_rvalue_completion_signatures<Signatures...>::value,
+      detail::completion_handler_async_result<CompletionToken, Signatures...>,
       async_result<CompletionToken,
-        BOOST_ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS>
-    >::type base_type;
+        typename detail::simple_completion_signature<Signatures>::type...>
+    > base_type;
 
   using base_type::base_type;
 
 private:
-  async_result(const async_result&) BOOST_ASIO_DELETED;
-  async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
+  async_result(const async_result&) = delete;
+  async_result& operator=(const async_result&) = delete;
 };
 
-#else // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
-
-template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
-class async_result :
-  public detail::completion_handler_async_result<
-    CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>
-{
-public:
-  explicit async_result(CompletionToken& h)
-    : detail::completion_handler_async_result<
-        CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>(h)
-  {
-  }
-
-private:
-  async_result(const async_result&) BOOST_ASIO_DELETED;
-  async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
-};
-
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
-
-template <BOOST_ASIO_COMPLETION_SIGNATURES_TSPECPARAMS>
-class async_result<void, BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>
+template <BOOST_ASIO_COMPLETION_SIGNATURE... Signatures>
+class async_result<void, Signatures...>
 {
   // Empty.
 };
@@ -641,65 +426,39 @@ class async_result<void, BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>
 /// Helper template to deduce the handler type from a CompletionToken, capture
 /// a local copy of the handler, and then create an async_result for the
 /// handler.
-template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
+template <typename CompletionToken,
+    BOOST_ASIO_COMPLETION_SIGNATURE... Signatures>
 struct async_completion
 {
   /// The real handler type to be used for the asynchronous operation.
   typedef typename boost::asio::async_result<
-    typename decay<CompletionToken>::type,
-      BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>::completion_handler_type
-        completion_handler_type;
+    decay_t<CompletionToken>, Signatures...>::completion_handler_type
+      completion_handler_type;
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
   /// Constructor.
   /**
    * The constructor creates the concrete completion handler and makes the link
    * between the handler and the asynchronous result.
    */
   explicit async_completion(CompletionToken& token)
-    : completion_handler(static_cast<typename conditional<
+    : completion_handler(static_cast<conditional_t<
         is_same<CompletionToken, completion_handler_type>::value,
-        completion_handler_type&, CompletionToken&&>::type>(token)),
-      result(completion_handler)
-  {
-  }
-#else // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  explicit async_completion(typename decay<CompletionToken>::type& token)
-    : completion_handler(token),
+        completion_handler_type&, CompletionToken&&>>(token)),
       result(completion_handler)
   {
   }
 
-  explicit async_completion(const typename decay<CompletionToken>::type& token)
-    : completion_handler(token),
-      result(completion_handler)
-  {
-  }
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-
   /// A copy of, or reference to, a real handler object.
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  typename conditional<
+  conditional_t<
     is_same<CompletionToken, completion_handler_type>::value,
-    completion_handler_type&, completion_handler_type>::type completion_handler;
-#else // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  completion_handler_type completion_handler;
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+    completion_handler_type&, completion_handler_type> completion_handler;
 
   /// The result of the asynchronous operation's initiating function.
-  async_result<typename decay<CompletionToken>::type,
-    BOOST_ASIO_COMPLETION_SIGNATURES_TARGS> result;
+  async_result<decay_t<CompletionToken>, Signatures...> result;
 };
 
 namespace detail {
 
-template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
-struct async_result_helper
-  : async_result<typename decay<CompletionToken>::type,
-      BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>
-{
-};
-
 struct async_result_memfns_base
 {
   void initiate();
@@ -725,11 +484,11 @@ char async_result_initiate_memfn_helper(
       void (async_result_memfns_base::*)(),
       &async_result_memfns_derived<T>::initiate>*);
 
-template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
+template <typename CompletionToken,
+    BOOST_ASIO_COMPLETION_SIGNATURE... Signatures>
 struct async_result_has_initiate_memfn
   : integral_constant<bool, sizeof(async_result_initiate_memfn_helper<
-      async_result<typename decay<CompletionToken>::type,
-        BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>
+      async_result<decay_t<CompletionToken>, Signatures...>
     >(0)) != 1>
 {
 };
@@ -743,25 +502,6 @@ struct async_result_has_initiate_memfn
   void_or_deduced
 # define BOOST_ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) \
   void_or_deduced
-#elif defined(_MSC_VER) && (_MSC_VER < 1500)
-# define BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig) \
-  typename ::boost::asio::detail::async_result_helper< \
-    ct, sig>::return_type
-# define BOOST_ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) \
-  typename ::boost::asio::detail::async_result_helper< \
-    ct, sig0, sig1>::return_type
-# define BOOST_ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) \
-  typename ::boost::asio::detail::async_result_helper< \
-    ct, sig0, sig1, sig2>::return_type
-#define BOOST_ASIO_HANDLER_TYPE(ct, sig) \
-  typename ::boost::asio::detail::async_result_helper< \
-    ct, sig>::completion_handler_type
-#define BOOST_ASIO_HANDLER_TYPE2(ct, sig0, sig1) \
-  typename ::boost::asio::detail::async_result_helper< \
-    ct, sig0, sig1>::completion_handler_type
-#define BOOST_ASIO_HANDLER_TYPE3(ct, sig0, sig1, sig2) \
-  typename ::boost::asio::detail::async_result_helper< \
-    ct, sig0, sig1, sig2>::completion_handler_type
 #else
 # define BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig) \
   typename ::boost::asio::async_result< \
@@ -824,7 +564,7 @@ struct async_result_has_initiate_memfn
 # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX3(ct, sig0, sig1, sig2) \
   auto
 # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(expr)
-#elif defined(BOOST_ASIO_HAS_DECLTYPE)
+#else
 # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ct, sig) \
   auto
 # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX2(ct, sig0, sig1) \
@@ -832,14 +572,6 @@ struct async_result_has_initiate_memfn
 # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX3(ct, sig0, sig1, sig2) \
   auto
 # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(expr) -> decltype expr
-#else
-# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ct, sig) \
-  BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig)
-# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX2(ct, sig0, sig1) \
-  BOOST_ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1)
-# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX3(ct, sig0, sig1, sig2) \
-  BOOST_ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2)
-# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(expr)
 #endif
 
 #if defined(GENERATING_DOCUMENTATION)
@@ -849,20 +581,13 @@ struct async_result_has_initiate_memfn
   void_or_deduced
 # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE3(ct, sig0, sig1, sig2, expr) \
   void_or_deduced
-#elif defined(BOOST_ASIO_HAS_DECLTYPE)
+#else
 # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \
   decltype expr
 # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE2(ct, sig0, sig1, expr) \
   decltype expr
 # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE3(ct, sig0, sig1, sig2, expr) \
   decltype expr
-#else
-# define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \
-  BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig)
-# define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE2(ct, sig0, sig1, expr) \
-  BOOST_ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1)
-# define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE3(ct, sig0, sig1, sig2, expr) \
-  BOOST_ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2)
 #endif
 
 #if defined(GENERATING_DOCUMENTATION)
@@ -871,326 +596,57 @@ template <typename CompletionToken,
     completion_signature... Signatures,
     typename Initiation, typename... Args>
 void_or_deduced async_initiate(
-    BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-    BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken),
-    BOOST_ASIO_MOVE_ARG(Args)... args);
+    Initiation&& initiation,
+    type_identity_t<CompletionToken>& token,
+    Args&&... args);
 
-#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+#else // defined(GENERATING_DOCUMENTATION)
 
 template <typename CompletionToken,
     BOOST_ASIO_COMPLETION_SIGNATURE... Signatures,
     typename Initiation, typename... Args>
-inline typename constraint<
+inline auto async_initiate(Initiation&& initiation,
+    type_identity_t<CompletionToken>& token, Args&&... args)
+  -> constraint_t<
     detail::async_result_has_initiate_memfn<
       CompletionToken, Signatures...>::value,
-    BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, Signatures...,
-      (async_result<typename decay<CompletionToken>::type,
-        Signatures...>::initiate(declval<BOOST_ASIO_MOVE_ARG(Initiation)>(),
-          declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>(),
-          declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))>::type
-async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-    BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token,
-    BOOST_ASIO_MOVE_ARG(Args)... args)
-{
-  return async_result<typename decay<CompletionToken>::type,
-    Signatures...>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
-      BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
-      BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    decltype(
+      async_result<decay_t<CompletionToken>, Signatures...>::initiate(
+        static_cast<Initiation&&>(initiation),
+        static_cast<CompletionToken&&>(token),
+        static_cast<Args&&>(args)...))>
+{
+  return async_result<decay_t<CompletionToken>, Signatures...>::initiate(
+      static_cast<Initiation&&>(initiation),
+      static_cast<CompletionToken&&>(token),
+      static_cast<Args&&>(args)...);
 }
 
 template <typename CompletionToken,
     BOOST_ASIO_COMPLETION_SIGNATURE... Signatures,
     typename Initiation, typename... Args>
-inline typename constraint<
+inline constraint_t<
     !detail::async_result_has_initiate_memfn<
       CompletionToken, Signatures...>::value,
-    BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Signatures...)>::type
-async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-    BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token,
-    BOOST_ASIO_MOVE_ARG(Args)... args)
+    typename async_result<decay_t<CompletionToken>, Signatures...>::return_type>
+async_initiate(Initiation&& initiation,
+    type_identity_t<CompletionToken>& token, Args&&... args)
 {
   async_completion<CompletionToken, Signatures...> completion(token);
 
-  BOOST_ASIO_MOVE_CAST(Initiation)(initiation)(
-      BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(CompletionToken,
-        Signatures...))(completion.completion_handler),
-      BOOST_ASIO_MOVE_CAST(Args)(args)...);
-
-  return completion.result.get();
-}
-
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-template <typename CompletionToken,
-    BOOST_ASIO_COMPLETION_SIGNATURE Sig0,
-    typename Initiation>
-inline typename constraint<
-    detail::async_result_has_initiate_memfn<
-      CompletionToken, Sig0>::value,
-    BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, Sig0,
-      (async_result<typename decay<CompletionToken>::type,
-        Sig0>::initiate(declval<BOOST_ASIO_MOVE_ARG(Initiation)>(),
-          declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>())))>::type
-async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-    BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token)
-{
-  return async_result<typename decay<CompletionToken>::type,
-    Sig0>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
-      BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
-}
-
-template <typename CompletionToken,
-    BOOST_ASIO_COMPLETION_SIGNATURE Sig0,
-    BOOST_ASIO_COMPLETION_SIGNATURE Sig1,
-    typename Initiation>
-inline typename constraint<
-    detail::async_result_has_initiate_memfn<
-      CompletionToken, Sig0, Sig1>::value,
-    BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE2(CompletionToken, Sig0, Sig1,
-      (async_result<typename decay<CompletionToken>::type,
-        Sig0, Sig1>::initiate(declval<BOOST_ASIO_MOVE_ARG(Initiation)>(),
-          declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>())))>::type
-async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-    BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token)
-{
-  return async_result<typename decay<CompletionToken>::type,
-    Sig0, Sig1>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
-      BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
-}
-
-template <typename CompletionToken,
-    BOOST_ASIO_COMPLETION_SIGNATURE Sig0,
-    BOOST_ASIO_COMPLETION_SIGNATURE Sig1,
-    BOOST_ASIO_COMPLETION_SIGNATURE Sig2,
-    typename Initiation>
-inline typename constraint<
-    detail::async_result_has_initiate_memfn<
-      CompletionToken, Sig0, Sig1, Sig2>::value,
-    BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE3(CompletionToken, Sig0, Sig1, Sig2,
-      (async_result<typename decay<CompletionToken>::type,
-        Sig0, Sig1, Sig2>::initiate(declval<BOOST_ASIO_MOVE_ARG(Initiation)>(),
-          declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>())))>::type
-async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-    BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token)
-{
-  return async_result<typename decay<CompletionToken>::type,
-    Sig0, Sig1, Sig2>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
-      BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
-}
-
-template <typename CompletionToken,
-    BOOST_ASIO_COMPLETION_SIGNATURE Sig0,
-    typename Initiation>
-inline typename constraint<
-    !detail::async_result_has_initiate_memfn<
-      CompletionToken, Sig0>::value,
-    BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Sig0)>::type
-async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-    BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token)
-{
-  async_completion<CompletionToken, Sig0> completion(token);
-
-  BOOST_ASIO_MOVE_CAST(Initiation)(initiation)(
-      BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(CompletionToken,
-        Sig0))(completion.completion_handler));
+  static_cast<Initiation&&>(initiation)(
+      static_cast<
+        typename async_result<decay_t<CompletionToken>,
+          Signatures...>::completion_handler_type&&>(
+            completion.completion_handler),
+      static_cast<Args&&>(args)...);
 
   return completion.result.get();
 }
 
-template <typename CompletionToken,
-    BOOST_ASIO_COMPLETION_SIGNATURE Sig0,
-    BOOST_ASIO_COMPLETION_SIGNATURE Sig1,
-    typename Initiation>
-inline typename constraint<
-    !detail::async_result_has_initiate_memfn<
-      CompletionToken, Sig0, Sig1>::value,
-    BOOST_ASIO_INITFN_RESULT_TYPE2(CompletionToken, Sig0, Sig1)>::type
-async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-    BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token)
-{
-  async_completion<CompletionToken, Sig0, Sig1> completion(token);
-
-  BOOST_ASIO_MOVE_CAST(Initiation)(initiation)(
-      BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE2(CompletionToken,
-        Sig0, Sig1))(completion.completion_handler));
-
-  return completion.result.get();
-}
-
-template <typename CompletionToken,
-    BOOST_ASIO_COMPLETION_SIGNATURE Sig0,
-    BOOST_ASIO_COMPLETION_SIGNATURE Sig1,
-    BOOST_ASIO_COMPLETION_SIGNATURE Sig2,
-    typename Initiation>
-inline typename constraint<
-    !detail::async_result_has_initiate_memfn<
-      CompletionToken, Sig0, Sig1, Sig2>::value,
-    BOOST_ASIO_INITFN_RESULT_TYPE3(CompletionToken, Sig0, Sig1, Sig2)>::type
-async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-    BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token)
-{
-  async_completion<CompletionToken, Sig0, Sig1, Sig2> completion(token);
-
-  BOOST_ASIO_MOVE_CAST(Initiation)(initiation)(
-      BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE3(CompletionToken,
-        Sig0, Sig1, Sig2))(completion.completion_handler));
-
-  return completion.result.get();
-}
+#endif // defined(GENERATING_DOCUMENTATION)
 
-#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
-  template <typename CompletionToken, \
-      BOOST_ASIO_COMPLETION_SIGNATURE Sig0, \
-      typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  inline typename constraint< \
-      detail::async_result_has_initiate_memfn< \
-        CompletionToken, Sig0>::value, \
-      BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE( \
-        CompletionToken, Sig0, \
-        (async_result<typename decay<CompletionToken>::type, \
-          Sig0>::initiate( \
-            declval<BOOST_ASIO_MOVE_ARG(Initiation)>(), \
-            declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>(), \
-            BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n))))>::type \
-  async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
-      BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-  { \
-    return async_result<typename decay<CompletionToken>::type, \
-      Sig0>::initiate( \
-        BOOST_ASIO_MOVE_CAST(Initiation)(initiation), \
-        BOOST_ASIO_MOVE_CAST(CompletionToken)(token), \
-        BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  \
-  template <typename CompletionToken, \
-      BOOST_ASIO_COMPLETION_SIGNATURE Sig0, \
-      BOOST_ASIO_COMPLETION_SIGNATURE Sig1, \
-      typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  inline typename constraint< \
-      detail::async_result_has_initiate_memfn< \
-        CompletionToken, Sig0, Sig1>::value, \
-      BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE2( \
-        CompletionToken, Sig0, Sig1, \
-        (async_result<typename decay<CompletionToken>::type, \
-          Sig0, Sig1>::initiate( \
-            declval<BOOST_ASIO_MOVE_ARG(Initiation)>(), \
-            declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>(), \
-            BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n))))>::type \
-  async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
-      BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-  { \
-    return async_result<typename decay<CompletionToken>::type, \
-      Sig0, Sig1>::initiate( \
-        BOOST_ASIO_MOVE_CAST(Initiation)(initiation), \
-        BOOST_ASIO_MOVE_CAST(CompletionToken)(token), \
-        BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  \
-  template <typename CompletionToken, \
-      BOOST_ASIO_COMPLETION_SIGNATURE Sig0, \
-      BOOST_ASIO_COMPLETION_SIGNATURE Sig1, \
-      BOOST_ASIO_COMPLETION_SIGNATURE Sig2, \
-      typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  inline typename constraint< \
-      detail::async_result_has_initiate_memfn< \
-        CompletionToken, Sig0, Sig1, Sig2>::value, \
-      BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE3( \
-        CompletionToken, Sig0, Sig1, Sig2, \
-        (async_result<typename decay<CompletionToken>::type, \
-          Sig0, Sig1, Sig2>::initiate( \
-            declval<BOOST_ASIO_MOVE_ARG(Initiation)>(), \
-            declval<BOOST_ASIO_MOVE_ARG(CompletionToken)>(), \
-            BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n))))>::type \
-  async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
-      BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-  { \
-    return async_result<typename decay<CompletionToken>::type, \
-      Sig0, Sig1, Sig2>::initiate( \
-        BOOST_ASIO_MOVE_CAST(Initiation)(initiation), \
-        BOOST_ASIO_MOVE_CAST(CompletionToken)(token), \
-        BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  \
-  template <typename CompletionToken, \
-      BOOST_ASIO_COMPLETION_SIGNATURE Sig0, \
-      typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  inline typename constraint< \
-      !detail::async_result_has_initiate_memfn< \
-        CompletionToken, Sig0>::value, \
-      BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Sig0)>::type \
-  async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
-      BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-  { \
-    async_completion<CompletionToken, \
-      Sig0> completion(token); \
-  \
-    BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( \
-        BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(CompletionToken, \
-          Sig0))(completion.completion_handler), \
-        BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  \
-    return completion.result.get(); \
-  } \
-  \
-  template <typename CompletionToken, \
-      BOOST_ASIO_COMPLETION_SIGNATURE Sig0, \
-      BOOST_ASIO_COMPLETION_SIGNATURE Sig1, \
-      typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  inline typename constraint< \
-      !detail::async_result_has_initiate_memfn< \
-        CompletionToken, Sig0, Sig1>::value, \
-      BOOST_ASIO_INITFN_RESULT_TYPE2(CompletionToken, Sig0, Sig1)>::type \
-  async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
-      BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-  { \
-    async_completion<CompletionToken, \
-      Sig0, Sig1> completion(token); \
-  \
-    BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( \
-        BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE2(CompletionToken, \
-          Sig0, Sig1))(completion.completion_handler), \
-        BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  \
-    return completion.result.get(); \
-  } \
-  \
-  template <typename CompletionToken, \
-      BOOST_ASIO_COMPLETION_SIGNATURE Sig0, \
-      BOOST_ASIO_COMPLETION_SIGNATURE Sig1, \
-      BOOST_ASIO_COMPLETION_SIGNATURE Sig2, \
-      typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  inline typename constraint< \
-      !detail::async_result_has_initiate_memfn< \
-        CompletionToken, Sig0, Sig1, Sig2>::value, \
-      BOOST_ASIO_INITFN_RESULT_TYPE3(CompletionToken, Sig0, Sig1, Sig2)>::type \
-  async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
-      BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-  { \
-    async_completion<CompletionToken, \
-      Sig0, Sig1, Sig2> completion(token); \
-  \
-    BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( \
-        BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE3(CompletionToken, \
-          Sig0, Sig1, Sig2))(completion.completion_handler), \
-        BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  \
-    return completion.result.get(); \
-  } \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF)
-#undef BOOST_ASIO_PRIVATE_INITIATE_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-#if defined(BOOST_ASIO_HAS_CONCEPTS) \
-  && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) \
-  && defined(BOOST_ASIO_HAS_DECLTYPE)
+#if defined(BOOST_ASIO_HAS_CONCEPTS)
 
 namespace detail {
 
@@ -1223,16 +679,12 @@ BOOST_ASIO_CONCEPT completion_token_for =
   ::boost::asio::completion_token_for<sig0, sig1, sig2>
 
 #else // defined(BOOST_ASIO_HAS_CONCEPTS)
-      //   && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-      //   && defined(BOOST_ASIO_HAS_DECLTYPE)
 
 #define BOOST_ASIO_COMPLETION_TOKEN_FOR(sig) typename
 #define BOOST_ASIO_COMPLETION_TOKEN_FOR2(sig0, sig1) typename
 #define BOOST_ASIO_COMPLETION_TOKEN_FOR3(sig0, sig1, sig2) typename
 
 #endif // defined(BOOST_ASIO_HAS_CONCEPTS)
-       //   && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-       //   && defined(BOOST_ASIO_HAS_DECLTYPE)
 
 namespace detail {
 
@@ -1246,21 +698,21 @@ struct is_async_operation_call : false_type
 
 template <typename Call>
 struct is_async_operation_call<Call,
-    typename void_type<
-      typename enable_if<
+    void_t<
+      enable_if_t<
         is_same<
-          typename result_of<Call>::type,
+          result_of_t<Call>,
           async_operation_probe_result
         >::value
-      >::type
-    >::type> : true_type
+      >
+    >
+  > : true_type
 {
 };
 
 } // namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename... Signatures>
 class async_result<detail::async_operation_probe, Signatures...>
@@ -1269,59 +721,16 @@ public:
   typedef detail::async_operation_probe_result return_type;
 
   template <typename Initiation, typename... InitArgs>
-  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation),
-      detail::async_operation_probe, BOOST_ASIO_MOVE_ARG(InitArgs)...)
+  static return_type initiate(Initiation&&,
+      detail::async_operation_probe, InitArgs&&...)
   {
     return return_type();
   }
 };
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-namespace detail {
-
-struct async_result_probe_base
-{
-  typedef detail::async_operation_probe_result return_type;
-
-  template <typename Initiation>
-  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation),
-      detail::async_operation_probe)
-  {
-    return return_type();
-  }
-
-#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
-  template <typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation), \
-      detail::async_operation_probe, \
-      BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS(n)) \
-  { \
-    return return_type(); \
-  } \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF)
-#undef BOOST_ASIO_PRIVATE_INITIATE_DEF
-};
-
-} // namespace detail
-
-template <typename Sig0>
-class async_result<detail::async_operation_probe, Sig0>
-  : public detail::async_result_probe_base {};
-
-template <typename Sig0, typename Sig1>
-class async_result<detail::async_operation_probe, Sig0, Sig1>
-  : public detail::async_result_probe_base {};
-
-template <typename Sig0, typename Sig1, typename Sig2>
-class async_result<detail::async_operation_probe, Sig0, Sig1, Sig2>
-  : public detail::async_result_probe_base {};
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 #endif // !defined(GENERATING_DOCUMENTATION)
 
-#if defined(GENERATION_DOCUMENTATION)
+#if defined(GENERATING_DOCUMENTATION)
 
 /// The is_async_operation trait detects whether a type @c T and arguments
 /// @c Args... may be used to initiate an asynchronous operation.
@@ -1336,7 +745,7 @@ struct is_async_operation : integral_constant<bool, automatically_determined>
 {
 };
 
-#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+#else // defined(GENERATING_DOCUMENTATION)
 
 template <typename T, typename... Args>
 struct is_async_operation :
@@ -1345,32 +754,9 @@ struct is_async_operation :
 {
 };
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-template <typename T, typename = void, typename = void, typename = void,
-    typename = void, typename = void, typename = void, typename = void,
-    typename = void, typename = void>
-struct is_async_operation :
-  detail::is_async_operation_call<
-    T(detail::async_operation_probe)>
-{
-};
-
-#define BOOST_ASIO_PRIVATE_IS_ASYNC_OP_DEF(n) \
-  template <typename T, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct is_async_operation<T, BOOST_ASIO_VARIADIC_TARGS(n)> : \
-    detail::is_async_operation_call< \
-      T(BOOST_ASIO_VARIADIC_TARGS(n), detail::async_operation_probe)> \
-  { \
-  }; \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_IS_ASYNC_OP_DEF)
-#undef BOOST_ASIO_PRIVATE_IS_ASYNC_OP_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+#endif // defined(GENERATING_DOCUMENTATION)
 
-#if defined(BOOST_ASIO_HAS_CONCEPTS) \
-  && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+#if defined(BOOST_ASIO_HAS_CONCEPTS)
 
 template <typename T, typename... Args>
 BOOST_ASIO_CONCEPT async_operation = is_async_operation<T, Args...>::value;
@@ -1385,7 +771,6 @@ BOOST_ASIO_CONCEPT async_operation = is_async_operation<T, Args...>::value;
   ::boost::asio::async_operation<t, a0, a1, a2>
 
 #else // defined(BOOST_ASIO_HAS_CONCEPTS)
-      //   && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 #define BOOST_ASIO_ASYNC_OPERATION(t) typename
 #define BOOST_ASIO_ASYNC_OPERATION1(t, a0) typename
@@ -1393,37 +778,56 @@ BOOST_ASIO_CONCEPT async_operation = is_async_operation<T, Args...>::value;
 #define BOOST_ASIO_ASYNC_OPERATION3(t, a0, a1, a2) typename
 
 #endif // defined(BOOST_ASIO_HAS_CONCEPTS)
-       //   && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 namespace detail {
 
 struct completion_signature_probe {};
 
-template <typename T>
+template <typename... T>
 struct completion_signature_probe_result
+{
+  template <template <typename...> class Op>
+  struct apply
+  {
+    typedef Op<T...> type;
+  };
+};
+
+template <typename T>
+struct completion_signature_probe_result<T>
 {
   typedef T type;
+
+  template <template <typename...> class Op>
+  struct apply
+  {
+    typedef Op<T> type;
+  };
 };
 
 template <>
 struct completion_signature_probe_result<void>
 {
+  template <template <typename...> class Op>
+  struct apply
+  {
+    typedef Op<> type;
+  };
 };
 
 } // namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename... Signatures>
 class async_result<detail::completion_signature_probe, Signatures...>
 {
 public:
-  typedef detail::completion_signature_probe_result<void> return_type;
+  typedef detail::completion_signature_probe_result<Signatures...> return_type;
 
   template <typename Initiation, typename... InitArgs>
-  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation),
-      detail::completion_signature_probe, BOOST_ASIO_MOVE_ARG(InitArgs)...)
+  static return_type initiate(Initiation&&,
+      detail::completion_signature_probe, InitArgs&&...)
   {
     return return_type();
   }
@@ -1436,62 +840,13 @@ public:
   typedef detail::completion_signature_probe_result<Signature> return_type;
 
   template <typename Initiation, typename... InitArgs>
-  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation),
-      detail::completion_signature_probe, BOOST_ASIO_MOVE_ARG(InitArgs)...)
-  {
-    return return_type();
-  }
-};
-
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-namespace detail {
-
-template <typename Signature>
-class async_result_sig_probe_base
-{
-public:
-  typedef detail::completion_signature_probe_result<Signature> return_type;
-
-  template <typename Initiation>
-  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation),
-      detail::async_operation_probe)
+  static return_type initiate(Initiation&&,
+      detail::completion_signature_probe, InitArgs&&...)
   {
     return return_type();
   }
-
-#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
-  template <typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation), \
-      detail::completion_signature_probe, \
-      BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS(n)) \
-  { \
-    return return_type(); \
-  } \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF)
-#undef BOOST_ASIO_PRIVATE_INITIATE_DEF
 };
 
-} // namespace detail
-
-template <>
-class async_result<detail::completion_signature_probe>
-  : public detail::async_result_sig_probe_base<void> {};
-
-template <typename Sig0>
-class async_result<detail::completion_signature_probe, Sig0>
-  : public detail::async_result_sig_probe_base<Sig0> {};
-
-template <typename Sig0, typename Sig1>
-class async_result<detail::completion_signature_probe, Sig0, Sig1>
-  : public detail::async_result_sig_probe_base<void> {};
-
-template <typename Sig0, typename Sig1, typename Sig2>
-class async_result<detail::completion_signature_probe, Sig0, Sig1, Sig2>
-  : public detail::async_result_sig_probe_base<void> {};
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 #endif // !defined(GENERATING_DOCUMENTATION)
 
 #if defined(GENERATING_DOCUMENTATION)
@@ -1514,47 +869,19 @@ struct completion_signature_of
   typedef automatically_determined type;
 };
 
-template <typename T, typename... Args>
-using completion_signature_of_t =
-  typename completion_signature_of<T, Args...>::type;
-
-#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+#else // defined(GENERATING_DOCUMENTATION)
 
 template <typename T, typename... Args>
 struct completion_signature_of :
-  result_of<T(Args..., detail::completion_signature_probe)>::type
+  result_of_t<T(Args..., detail::completion_signature_probe)>
 {
 };
 
-#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+#endif // defined(GENERATING_DOCUMENTATION)
+
 template <typename T, typename... Args>
 using completion_signature_of_t =
   typename completion_signature_of<T, Args...>::type;
-#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
-
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-template <typename T, typename = void, typename = void, typename = void,
-    typename = void, typename = void, typename = void, typename = void,
-    typename = void, typename = void>
-struct completion_signature_of :
-  result_of<T(detail::completion_signature_probe)>::type
-{
-};
-
-#define BOOST_ASIO_PRIVATE_COMPLETION_SIG_OF_DEF(n) \
-  template <typename T, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  struct completion_signature_of<T, BOOST_ASIO_VARIADIC_TARGS(n)> : \
-    result_of< \
-      T(BOOST_ASIO_VARIADIC_TARGS(n), \
-        detail::completion_signature_probe)>::type \
-  { \
-  }; \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_COMPLETION_SIG_OF_DEF)
-#undef BOOST_ASIO_PRIVATE_COMPLETION_SIG_OF_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 namespace detail {
 
@@ -1566,7 +893,8 @@ struct default_completion_token_impl
 
 template <typename T>
 struct default_completion_token_impl<T,
-  typename void_type<typename T::default_completion_token_type>::type>
+    void_t<typename T::default_completion_token_type>
+  >
 {
   typedef typename T::default_completion_token_type type;
 };
@@ -1600,27 +928,14 @@ struct default_completion_token
 };
 #endif
 
-#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
-
 template <typename T>
 using default_completion_token_t = typename default_completion_token<T>::type;
 
-#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
-
-#if defined(BOOST_ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS)
-
 #define BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(e) \
   = typename ::boost::asio::default_completion_token<e>::type
 #define BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(e) \
   = typename ::boost::asio::default_completion_token<e>::type()
 
-#else // defined(BOOST_ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS)
-
-#define BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(e)
-#define BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(e)
-
-#endif // defined(BOOST_ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS)
-
 } // namespace asio
 } // namespace boost