diff --git a/Jamroot b/Jamroot
index bf05265f80f255dedb0b9d0df57b66698fcc3773..cc82d03ffcaba0cbcfe5bcd43c8521cce6a3452d 100644
--- a/Jamroot
+++ b/Jamroot
@@ -144,7 +144,7 @@ import option ;
 import tools/boost\_install/boost-install ;
 
 path-constant BOOST_ROOT : . ;
-constant BOOST_VERSION : 1.76.0 ;
+constant BOOST_VERSION : 1.79.0 ;
 constant BOOST_JAMROOT_MODULE : $(__name__) ;
 
 # Allow subprojects to simply `import config : requires ;` to get access to the requires rule
@@ -213,18 +213,15 @@ rule handle-static-runtime ( properties * )
     # dangerous on Windows. Therefore, we disallow it. This might be drastic,
     # but it was disabled for a while without anybody complaining.
 
-    # For CW, static runtime is needed so that std::locale works.
-    if <link>shared in $(properties) && <runtime-link>static in $(properties) &&
-        ! ( <toolset>cw in $(properties) )
-    {
-        if ! $(.shared-static-warning-emitted)
-        {
-            ECHO "warning: skipping configuration link=shared, runtime-link=static" ;
-            ECHO "warning: this combination is either impossible or too dangerous" ;
-            ECHO "warning: to be of any use" ;
-            .shared-static-warning-emitted = 1 ;
-        }
+    local argv = [ modules.peek : ARGV ] ;
 
+    if <link>shared in $(properties)
+        && <runtime-link>static in $(properties)
+        # For CW, static runtime is needed so that std::locale works.
+        && ! ( <toolset>cw in $(properties) )
+        && ! --allow-shared-static in $(argv)
+    {
+        boostcpp.emit-shared-static-warning ;
         return <build>no ;
     }
 }
diff --git a/README.OpenSource b/README.OpenSource
index 36dd2a28375c8713e329a7c68ad19c024d3c83ea..8c1e7c28c929372f64f168ce30b7728c0fe77c4d 100644
--- a/README.OpenSource
+++ b/README.OpenSource
@@ -3,7 +3,7 @@
         "Name": "Boost",
         "License": "Boost Software License V1.0",
         "License File": "LICENSE_1_0.txt",
-        "Version Number": "1.76.0",
+        "Version Number": "1.79.0",
         "Owner": "wangyongjun7@huawei.com",
         "Upstream URL": "http://www.boost.org/",
         "Description": "Boost provides free portable peer-reviewed C++ libraries. The emphasis is on portable libraries which work well with the C++ Standard Library. See http://www.boost.org"
diff --git a/boost/asio.hpp b/boost/asio.hpp
index 362f721792d95aec97e1636fe18f09fe2ed25c88..a1c1c378eb6d5d5fe9d98273c92f0f01e15a7f08 100644
--- a/boost/asio.hpp
+++ b/boost/asio.hpp
@@ -2,7 +2,7 @@
 // asio.hpp
 // ~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,12 +19,17 @@
 
 #include <boost/asio/associated_allocator.hpp>
 #include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/awaitable.hpp>
 #include <boost/asio/basic_datagram_socket.hpp>
 #include <boost/asio/basic_deadline_timer.hpp>
+#include <boost/asio/basic_file.hpp>
 #include <boost/asio/basic_io_object.hpp>
+#include <boost/asio/basic_random_access_file.hpp>
 #include <boost/asio/basic_raw_socket.hpp>
+#include <boost/asio/basic_readable_pipe.hpp>
 #include <boost/asio/basic_seq_packet_socket.hpp>
 #include <boost/asio/basic_serial_port.hpp>
 #include <boost/asio/basic_signal_set.hpp>
@@ -32,11 +37,16 @@
 #include <boost/asio/basic_socket_acceptor.hpp>
 #include <boost/asio/basic_socket_iostream.hpp>
 #include <boost/asio/basic_socket_streambuf.hpp>
+#include <boost/asio/basic_stream_file.hpp>
 #include <boost/asio/basic_stream_socket.hpp>
 #include <boost/asio/basic_streambuf.hpp>
 #include <boost/asio/basic_waitable_timer.hpp>
+#include <boost/asio/basic_writable_pipe.hpp>
+#include <boost/asio/bind_allocator.hpp>
+#include <boost/asio/bind_cancellation_slot.hpp>
 #include <boost/asio/bind_executor.hpp>
 #include <boost/asio/buffer.hpp>
+#include <boost/asio/buffer_registration.hpp>
 #include <boost/asio/buffered_read_stream_fwd.hpp>
 #include <boost/asio/buffered_read_stream.hpp>
 #include <boost/asio/buffered_stream_fwd.hpp>
@@ -44,10 +54,14 @@
 #include <boost/asio/buffered_write_stream_fwd.hpp>
 #include <boost/asio/buffered_write_stream.hpp>
 #include <boost/asio/buffers_iterator.hpp>
+#include <boost/asio/cancellation_signal.hpp>
+#include <boost/asio/cancellation_state.hpp>
+#include <boost/asio/cancellation_type.hpp>
 #include <boost/asio/co_spawn.hpp>
 #include <boost/asio/completion_condition.hpp>
 #include <boost/asio/compose.hpp>
 #include <boost/asio/connect.hpp>
+#include <boost/asio/connect_pipe.hpp>
 #include <boost/asio/coroutine.hpp>
 #include <boost/asio/deadline_timer.hpp>
 #include <boost/asio/defer.hpp>
@@ -85,6 +99,7 @@
 #include <boost/asio/execution_context.hpp>
 #include <boost/asio/executor.hpp>
 #include <boost/asio/executor_work_guard.hpp>
+#include <boost/asio/file_base.hpp>
 #include <boost/asio/generic/basic_endpoint.hpp>
 #include <boost/asio/generic/datagram_protocol.hpp>
 #include <boost/asio/generic/raw_protocol.hpp>
@@ -141,10 +156,14 @@
 #include <boost/asio/post.hpp>
 #include <boost/asio/prefer.hpp>
 #include <boost/asio/query.hpp>
+#include <boost/asio/random_access_file.hpp>
 #include <boost/asio/read.hpp>
 #include <boost/asio/read_at.hpp>
 #include <boost/asio/read_until.hpp>
+#include <boost/asio/readable_pipe.hpp>
+#include <boost/asio/recycling_allocator.hpp>
 #include <boost/asio/redirect_error.hpp>
+#include <boost/asio/registered_buffer.hpp>
 #include <boost/asio/require.hpp>
 #include <boost/asio/require_concept.hpp>
 #include <boost/asio/serial_port.hpp>
@@ -154,6 +173,7 @@
 #include <boost/asio/static_thread_pool.hpp>
 #include <boost/asio/steady_timer.hpp>
 #include <boost/asio/strand.hpp>
+#include <boost/asio/stream_file.hpp>
 #include <boost/asio/streambuf.hpp>
 #include <boost/asio/system_context.hpp>
 #include <boost/asio/system_executor.hpp>
@@ -175,6 +195,7 @@
 #include <boost/asio/windows/overlapped_ptr.hpp>
 #include <boost/asio/windows/random_access_handle.hpp>
 #include <boost/asio/windows/stream_handle.hpp>
+#include <boost/asio/writable_pipe.hpp>
 #include <boost/asio/write.hpp>
 #include <boost/asio/write_at.hpp>
 
diff --git a/boost/asio/any_io_executor.hpp b/boost/asio/any_io_executor.hpp
index 8eb3d724bd04a7f587a3dfde68c81dfe5c0beee4..6dc8731fdcaee0b5b16afa21d0d57a7bd66ec023 100644
--- a/boost/asio/any_io_executor.hpp
+++ b/boost/asio/any_io_executor.hpp
@@ -2,7 +2,7 @@
 // any_io_executor.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -88,29 +88,17 @@ public:
 #endif // !defined(GENERATING_DOCUMENTATION)
 
   /// Default constructor.
-  any_io_executor() BOOST_ASIO_NOEXCEPT
-    : base_type()
-  {
-  }
+  BOOST_ASIO_DECL any_io_executor() BOOST_ASIO_NOEXCEPT;
 
   /// Construct in an empty state. Equivalent effects to default constructor.
-  any_io_executor(nullptr_t) BOOST_ASIO_NOEXCEPT
-    : base_type(nullptr_t())
-  {
-  }
+  BOOST_ASIO_DECL any_io_executor(nullptr_t) BOOST_ASIO_NOEXCEPT;
 
   /// Copy constructor.
-  any_io_executor(const any_io_executor& e) BOOST_ASIO_NOEXCEPT
-    : base_type(static_cast<const base_type&>(e))
-  {
-  }
+  BOOST_ASIO_DECL any_io_executor(const any_io_executor& e) BOOST_ASIO_NOEXCEPT;
 
 #if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
   /// Move constructor.
-  any_io_executor(any_io_executor&& e) BOOST_ASIO_NOEXCEPT
-    : base_type(static_cast<base_type&&>(e))
-  {
-  }
+  BOOST_ASIO_DECL any_io_executor(any_io_executor&& e) BOOST_ASIO_NOEXCEPT;
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Construct to point to the same target as another any_executor.
@@ -159,38 +147,23 @@ public:
 #endif // defined(GENERATING_DOCUMENTATION)
 
   /// Assignment operator.
-  any_io_executor& operator=(const any_io_executor& e) BOOST_ASIO_NOEXCEPT
-  {
-    base_type::operator=(static_cast<const base_type&>(e));
-    return *this;
-  }
+  BOOST_ASIO_DECL any_io_executor& operator=(
+      const any_io_executor& e) BOOST_ASIO_NOEXCEPT;
 
 #if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
   /// Move assignment operator.
-  any_io_executor& operator=(any_io_executor&& e) BOOST_ASIO_NOEXCEPT
-  {
-    base_type::operator=(static_cast<base_type&&>(e));
-    return *this;
-  }
+  BOOST_ASIO_DECL any_io_executor& operator=(
+      any_io_executor&& e) BOOST_ASIO_NOEXCEPT;
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Assignment operator that sets the polymorphic wrapper to the empty state.
-  any_io_executor& operator=(nullptr_t)
-  {
-    base_type::operator=(nullptr_t());
-    return *this;
-  }
+  BOOST_ASIO_DECL any_io_executor& operator=(nullptr_t);
 
   /// Destructor.
-  ~any_io_executor()
-  {
-  }
+  BOOST_ASIO_DECL ~any_io_executor();
 
   /// Swap targets with another polymorphic wrapper.
-  void swap(any_io_executor& other) BOOST_ASIO_NOEXCEPT
-  {
-    static_cast<base_type&>(*this).swap(static_cast<base_type&>(other));
-  }
+  BOOST_ASIO_DECL void swap(any_io_executor& other) BOOST_ASIO_NOEXCEPT;
 
   /// Obtain a polymorphic wrapper with the specified property.
   /**
@@ -231,6 +204,30 @@ public:
 
 #if !defined(GENERATING_DOCUMENTATION)
 
+template <>
+BOOST_ASIO_DECL any_io_executor any_io_executor::require(
+    const execution::blocking_t::never_t&, int) const;
+
+template <>
+BOOST_ASIO_DECL any_io_executor any_io_executor::prefer(
+    const execution::blocking_t::possibly_t&, int) const;
+
+template <>
+BOOST_ASIO_DECL any_io_executor any_io_executor::prefer(
+    const execution::outstanding_work_t::tracked_t&, int) const;
+
+template <>
+BOOST_ASIO_DECL any_io_executor any_io_executor::prefer(
+    const execution::outstanding_work_t::untracked_t&, int) const;
+
+template <>
+BOOST_ASIO_DECL any_io_executor any_io_executor::prefer(
+    const execution::relationship_t::fork_t&, int) const;
+
+template <>
+BOOST_ASIO_DECL any_io_executor any_io_executor::prefer(
+    const execution::relationship_t::continuation_t&, int) const;
+
 namespace traits {
 
 #if !defined(BOOST_ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
@@ -299,4 +296,10 @@ struct prefer_member<any_io_executor, Prop> :
 
 #include <boost/asio/detail/pop_options.hpp>
 
+#if defined(BOOST_ASIO_HEADER_ONLY) \
+  && !defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+# include <boost/asio/impl/any_io_executor.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+       //   && !defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
 #endif // BOOST_ASIO_ANY_IO_EXECUTOR_HPP
diff --git a/boost/asio/associated_allocator.hpp b/boost/asio/associated_allocator.hpp
index 76e8a9b88307a8908077253b296afdc8b436b79b..01c020269b72dfcccb2d62d8347bf62e7687444c 100644
--- a/boost/asio/associated_allocator.hpp
+++ b/boost/asio/associated_allocator.hpp
@@ -2,7 +2,7 @@
 // associated_allocator.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,15 +17,33 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <memory>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/detail/functional.hpp>
 #include <boost/asio/detail/type_traits.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
+
+template <typename T, typename Allocator>
+struct associated_allocator;
+
 namespace detail {
 
-template <typename T, typename E, typename = void>
+template <typename T, typename = void>
+struct has_allocator_type : false_type
+{
+};
+
+template <typename T>
+struct has_allocator_type<T,
+  typename void_type<typename T::allocator_type>::type>
+    : true_type
+{
+};
+
+template <typename T, typename E, typename = void, typename = void>
 struct associated_allocator_impl
 {
   typedef E type;
@@ -48,6 +66,17 @@ struct associated_allocator_impl<T, E,
   }
 };
 
+template <typename T, typename E>
+struct associated_allocator_impl<T, E,
+  typename enable_if<
+    !has_allocator_type<T>::value
+  >::type,
+  typename void_type<
+    typename associator<associated_allocator, T, E>::type
+  >::type> : associator<associated_allocator, T, E>
+{
+};
+
 } // namespace detail
 
 /// Traits type used to obtain the allocator associated with an object.
@@ -94,7 +123,7 @@ struct associated_allocator
  * @returns <tt>associated_allocator<T>::get(t)</tt>
  */
 template <typename T>
-inline typename associated_allocator<T>::type
+BOOST_ASIO_NODISCARD inline typename associated_allocator<T>::type
 get_associated_allocator(const T& t) BOOST_ASIO_NOEXCEPT
 {
   return associated_allocator<T>::get(t);
@@ -105,7 +134,7 @@ get_associated_allocator(const T& t) BOOST_ASIO_NOEXCEPT
  * @returns <tt>associated_allocator<T, Allocator>::get(t, a)</tt>
  */
 template <typename T, typename Allocator>
-inline typename associated_allocator<T, Allocator>::type
+BOOST_ASIO_NODISCARD inline typename associated_allocator<T, Allocator>::type
 get_associated_allocator(const T& t, const Allocator& a) BOOST_ASIO_NOEXCEPT
 {
   return associated_allocator<T, Allocator>::get(t, a);
@@ -119,6 +148,29 @@ using associated_allocator_t
 
 #endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
 
+#if defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Specialisation of associated_allocator for @c std::reference_wrapper.
+template <typename T, typename Allocator>
+struct associated_allocator<reference_wrapper<T>, Allocator>
+{
+  /// Forwards @c type to the associator specialisation for the unwrapped type
+  /// @c T.
+  typedef typename associated_allocator<T, Allocator>::type type;
+
+  /// Forwards the request to get the allocator to the associator specialisation
+  /// for the unwrapped type @c T.
+  static type get(reference_wrapper<T> t,
+      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_allocator<T, Allocator>::get(t.get(), a);
+  }
+};
+
+#endif // defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER)
+       //   || defined(GENERATING_DOCUMENTATION)
+
 } // namespace asio
 } // namespace boost
 
diff --git a/boost/asio/associated_cancellation_slot.hpp b/boost/asio/associated_cancellation_slot.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f3f52e733721aa904c82321222bc51b71b58b20c
--- /dev/null
+++ b/boost/asio/associated_cancellation_slot.hpp
@@ -0,0 +1,180 @@
+//
+// associated_cancellation_slot.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_ASSOCIATED_CANCELLATION_SLOT_HPP
+#define BOOST_ASIO_ASSOCIATED_CANCELLATION_SLOT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/cancellation_signal.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename T, typename CancellationSlot>
+struct associated_cancellation_slot;
+
+namespace detail {
+
+template <typename T, typename = void>
+struct has_cancellation_slot_type : false_type
+{
+};
+
+template <typename T>
+struct has_cancellation_slot_type<T,
+  typename void_type<typename T::cancellation_slot_type>::type>
+    : true_type
+{
+};
+
+template <typename T, typename S, typename = void, typename = void>
+struct associated_cancellation_slot_impl
+{
+  typedef void asio_associated_cancellation_slot_is_unspecialised;
+
+  typedef S type;
+
+  static type get(const T&, const S& s = S()) BOOST_ASIO_NOEXCEPT
+  {
+    return s;
+  }
+};
+
+template <typename T, typename S>
+struct associated_cancellation_slot_impl<T, S,
+  typename void_type<typename T::cancellation_slot_type>::type>
+{
+  typedef typename T::cancellation_slot_type type;
+
+  static type get(const T& t, const S& = S()) BOOST_ASIO_NOEXCEPT
+  {
+    return t.get_cancellation_slot();
+  }
+};
+
+template <typename T, typename S>
+struct associated_cancellation_slot_impl<T, S,
+  typename enable_if<
+    !has_cancellation_slot_type<T>::value
+  >::type,
+  typename void_type<
+    typename associator<associated_cancellation_slot, T, S>::type
+  >::type> : associator<associated_cancellation_slot, T, S>
+{
+};
+
+} // namespace detail
+
+/// Traits type used to obtain the cancellation_slot associated with an object.
+/**
+ * A program may specialise this traits type if the @c T template parameter in
+ * the specialisation is a user-defined type. The template parameter @c
+ * CancellationSlot shall be a type meeting the CancellationSlot requirements.
+ *
+ * Specialisations shall meet the following requirements, where @c t is a const
+ * reference to an object of type @c T, and @c s is an object of type @c
+ * CancellationSlot.
+ *
+ * @li Provide a nested typedef @c type that identifies a type meeting the
+ * CancellationSlot requirements.
+ *
+ * @li Provide a noexcept static member function named @c get, callable as @c
+ * get(t) and with return type @c type.
+ *
+ * @li Provide a noexcept static member function named @c get, callable as @c
+ * get(t,s) and with return type @c type.
+ */
+template <typename T, typename CancellationSlot = cancellation_slot>
+struct associated_cancellation_slot
+#if !defined(GENERATING_DOCUMENTATION)
+  : detail::associated_cancellation_slot_impl<T, CancellationSlot>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+#if defined(GENERATING_DOCUMENTATION)
+  /// If @c T has a nested type @c cancellation_slot_type,
+  /// <tt>T::cancellation_slot_type</tt>. Otherwise
+  /// @c CancellationSlot.
+  typedef see_below type;
+
+  /// If @c T has a nested type @c cancellation_slot_type, returns
+  /// <tt>t.get_cancellation_slot()</tt>. Otherwise returns @c s.
+  static type get(const T& t,
+      const CancellationSlot& s = CancellationSlot()) BOOST_ASIO_NOEXCEPT;
+#endif // defined(GENERATING_DOCUMENTATION)
+};
+
+/// Helper function to obtain an object's associated cancellation_slot.
+/**
+ * @returns <tt>associated_cancellation_slot<T>::get(t)</tt>
+ */
+template <typename T>
+BOOST_ASIO_NODISCARD inline typename associated_cancellation_slot<T>::type
+get_associated_cancellation_slot(const T& t) BOOST_ASIO_NOEXCEPT
+{
+  return associated_cancellation_slot<T>::get(t);
+}
+
+/// Helper function to obtain an object's associated cancellation_slot.
+/**
+ * @returns <tt>associated_cancellation_slot<T,
+ * CancellationSlot>::get(t, st)</tt>
+ */
+template <typename T, typename CancellationSlot>
+BOOST_ASIO_NODISCARD inline
+typename associated_cancellation_slot<T, CancellationSlot>::type
+get_associated_cancellation_slot(const T& t,
+    const CancellationSlot& st) BOOST_ASIO_NOEXCEPT
+{
+  return associated_cancellation_slot<T, CancellationSlot>::get(t, st);
+}
+
+#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+
+template <typename T, typename CancellationSlot = cancellation_slot>
+using associated_cancellation_slot_t =
+  typename associated_cancellation_slot<T, CancellationSlot>::type;
+
+#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+
+namespace detail {
+
+template <typename T, typename S, typename = void>
+struct associated_cancellation_slot_forwarding_base
+{
+};
+
+template <typename T, typename S>
+struct associated_cancellation_slot_forwarding_base<T, S,
+    typename enable_if<
+      is_same<
+        typename associated_cancellation_slot<T,
+          S>::asio_associated_cancellation_slot_is_unspecialised,
+        void
+      >::value
+    >::type>
+{
+  typedef void asio_associated_cancellation_slot_is_unspecialised;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_ASSOCIATED_CANCELLATION_SLOT_HPP
diff --git a/boost/asio/associated_executor.hpp b/boost/asio/associated_executor.hpp
index 6d4ac65f3b0070d41213b7a5118c73de7870c09f..02738aac820d6270bedb0abc8424b585e1795d3d 100644
--- a/boost/asio/associated_executor.hpp
+++ b/boost/asio/associated_executor.hpp
@@ -2,7 +2,7 @@
 // associated_executor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,6 +16,8 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/detail/functional.hpp>
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/execution/executor.hpp>
 #include <boost/asio/is_executor.hpp>
@@ -25,9 +27,25 @@
 
 namespace boost {
 namespace asio {
+
+template <typename T, typename Executor>
+struct associated_executor;
+
 namespace detail {
 
-template <typename T, typename E, typename = void>
+template <typename T, typename = void>
+struct has_executor_type : false_type
+{
+};
+
+template <typename T>
+struct has_executor_type<T,
+  typename void_type<typename T::executor_type>::type>
+    : true_type
+{
+};
+
+template <typename T, typename E, typename = void, typename = void>
 struct associated_executor_impl
 {
   typedef void asio_associated_executor_is_unspecialised;
@@ -52,6 +70,17 @@ struct associated_executor_impl<T, E,
   }
 };
 
+template <typename T, typename E>
+struct associated_executor_impl<T, E,
+  typename enable_if<
+    !has_executor_type<T>::value
+  >::type,
+  typename void_type<
+    typename associator<associated_executor, T, E>::type
+  >::type> : associator<associated_executor, T, E>
+{
+};
+
 } // namespace detail
 
 /// Traits type used to obtain the executor associated with an object.
@@ -96,7 +125,7 @@ struct associated_executor
  * @returns <tt>associated_executor<T>::get(t)</tt>
  */
 template <typename T>
-inline typename associated_executor<T>::type
+BOOST_ASIO_NODISCARD inline typename associated_executor<T>::type
 get_associated_executor(const T& t) BOOST_ASIO_NOEXCEPT
 {
   return associated_executor<T>::get(t);
@@ -107,7 +136,7 @@ get_associated_executor(const T& t) BOOST_ASIO_NOEXCEPT
  * @returns <tt>associated_executor<T, Executor>::get(t, ex)</tt>
  */
 template <typename T, typename Executor>
-inline typename associated_executor<T, Executor>::type
+BOOST_ASIO_NODISCARD inline typename associated_executor<T, Executor>::type
 get_associated_executor(const T& t, const Executor& ex,
     typename constraint<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
@@ -122,7 +151,7 @@ get_associated_executor(const T& t, const Executor& ex,
  * ExecutionContext::executor_type>::get(t, ctx.get_executor())</tt>
  */
 template <typename T, typename ExecutionContext>
-inline typename associated_executor<T,
+BOOST_ASIO_NODISCARD inline typename associated_executor<T,
   typename ExecutionContext::executor_type>::type
 get_associated_executor(const T& t, ExecutionContext& ctx,
     typename constraint<is_convertible<ExecutionContext&,
@@ -160,6 +189,33 @@ struct associated_executor_forwarding_base<T, E,
 };
 
 } // namespace detail
+
+#if defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER) \
+  || defined(GENERATING_DOCUMENTATION)
+
+/// Specialisation of associated_executor for @c std::reference_wrapper.
+template <typename T, typename Executor>
+struct associated_executor<reference_wrapper<T>, Executor>
+#if !defined(GENERATING_DOCUMENTATION)
+  : detail::associated_executor_forwarding_base<T, Executor>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+  /// Forwards @c type to the associator specialisation for the unwrapped type
+  /// @c T.
+  typedef typename associated_executor<T, Executor>::type type;
+
+  /// Forwards the request to get the executor to the associator specialisation
+  /// for the unwrapped type @c T.
+  static type get(reference_wrapper<T> t,
+      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  {
+    return associated_executor<T, Executor>::get(t.get(), ex);
+  }
+};
+
+#endif // defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER)
+       //   || defined(GENERATING_DOCUMENTATION)
+
 } // namespace asio
 } // namespace boost
 
diff --git a/boost/asio/associator.hpp b/boost/asio/associator.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..bc775b01078db98875652940b6188d7be2c0b9e5
--- /dev/null
+++ b/boost/asio/associator.hpp
@@ -0,0 +1,37 @@
+//
+// associator.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_ASSOCIATOR_HPP
+#define BOOST_ASIO_ASSOCIATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Used to generically specialise associators for a type.
+template <template <typename, typename> class Associator,
+    typename T, typename DefaultCandidate>
+struct associator
+{
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_ASSOCIATOR_HPP
diff --git a/boost/asio/async_result.hpp b/boost/asio/async_result.hpp
index 3bcf424619660e21eb1f4a5de7a652d6e890991c..1e735cbee23dac61042ab2565371e353a051ca93 100644
--- a/boost/asio/async_result.hpp
+++ b/boost/asio/async_result.hpp
@@ -2,7 +2,7 @@
 // async_result.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -40,13 +40,64 @@ 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
+{
+};
+
+template <typename R, typename... Args>
+struct is_completion_signature<R(Args...) &&> : true_type
+{
+};
+
+# if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
+template <typename R, typename... Args>
+struct is_completion_signature<R(Args...) noexcept> : true_type
+{
+};
+
+template <typename R, typename... Args>
+struct is_completion_signature<R(Args...) & noexcept> : true_type
+{
+};
+
+template <typename R, typename... Args>
+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
+{
+};
+
+template <typename T0>
+struct are_completion_signatures<T0>
+  : is_completion_signature<T0>
+{
+};
+
+template <typename T0, typename... TN>
+struct are_completion_signatures<T0, TN...>
+  : integral_constant<bool, (
+      is_completion_signature<T0>::value
+        && are_completion_signatures<TN...>::value)>
+{
+};
+
 template <typename T, typename... Args>
-BOOST_ASIO_CONCEPT callable_with = requires(T t, Args&&... args)
+BOOST_ASIO_CONCEPT callable_with = requires(T&& t, Args&&... args)
 {
-  t(static_cast<Args&&>(args)...);
+  static_cast<T&&>(t)(static_cast<Args&&>(args)...);
 };
 
-template <typename T, typename Signature>
+template <typename T, typename... Signatures>
 struct is_completion_handler_for : false_type
 {
 };
@@ -57,6 +108,51 @@ struct is_completion_handler_for<T, R(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...>)>
+{
+};
+
+template <typename T, typename R, typename... Args>
+struct is_completion_handler_for<T, R(Args...) &&>
+  : integral_constant<bool, (callable_with<T&&, Args...>)>
+{
+};
+
+# if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
+template <typename T, typename R, typename... Args>
+struct is_completion_handler_for<T, R(Args...) noexcept>
+  : integral_constant<bool, (callable_with<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...>)>
+{
+};
+
+template <typename T, typename R, typename... Args>
+struct is_completion_handler_for<T, R(Args...) && noexcept>
+  : integral_constant<bool, (callable_with<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...>
+  : integral_constant<bool, (
+      is_completion_handler_for<T, Signature0>::value
+        && is_completion_handler_for<T, SignatureN...>::value)>
+{
+};
+
 } // namespace detail
 
 template <typename T>
@@ -66,83 +162,317 @@ BOOST_ASIO_CONCEPT completion_signature =
 #define BOOST_ASIO_COMPLETION_SIGNATURE \
   ::boost::asio::completion_signature
 
-template <typename T, typename Signature>
+template <typename T, typename... Signatures>
 BOOST_ASIO_CONCEPT completion_handler_for =
-  detail::is_completion_signature<Signature>::value
-    && detail::is_completion_handler_for<T, Signature>::value;
+  detail::are_completion_signatures<Signatures...>::value
+    && detail::is_completion_handler_for<T, Signatures...>::value;
 
-#define BOOST_ASIO_COMPLETION_HANDLER_FOR(s) \
-  ::boost::asio::completion_handler_for<s>
+#define BOOST_ASIO_COMPLETION_HANDLER_FOR(sig) \
+  ::boost::asio::completion_handler_for<sig>
+#define BOOST_ASIO_COMPLETION_HANDLER_FOR2(sig0, sig1) \
+  ::boost::asio::completion_handler_for<sig0, sig1>
+#define BOOST_ASIO_COMPLETION_HANDLER_FOR3(sig0, sig1, sig2) \
+  ::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(s) typename
+#define BOOST_ASIO_COMPLETION_HANDLER_FOR(sig) typename
+#define BOOST_ASIO_COMPLETION_HANDLER_FOR2(sig0, sig1) typename
+#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)
 
-/// An interface for customising the behaviour of an initiating function.
-/**
- * The async_result traits class is used for determining:
- *
- * @li the concrete completion handler type to be called at the end of the
- * asynchronous operation;
- *
- * @li the initiating function return type; and
- *
- * @li how the return value of the initiating function is obtained.
- *
- * The trait allows the handler and return types to be determined at the point
- * where the specific completion handler signature is known.
- *
- * This template may be specialised for user-defined completion token types.
- * The primary template assumes that the CompletionToken is the completion
- * handler.
- */
-template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURE Signature>
-class async_result
+namespace detail {
+
+template <typename T>
+struct is_simple_completion_signature : false_type
+{
+};
+
+template <typename T>
+struct simple_completion_signature;
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename R, typename... Args>
+struct is_simple_completion_signature<R(Args...)> : true_type
+{
+};
+
+template <typename... Signatures>
+struct are_simple_completion_signatures : false_type
+{
+};
+
+template <typename Sig0>
+struct are_simple_completion_signatures<Sig0>
+  : is_simple_completion_signature<Sig0>
+{
+};
+
+template <typename Sig0, typename... SigN>
+struct are_simple_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...)>
+{
+  typedef R type(Args...);
+};
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+template <typename R, typename... Args>
+struct simple_completion_signature<R(Args...) &>
+{
+  typedef R type(Args...);
+};
+
+template <typename R, typename... Args>
+struct simple_completion_signature<R(Args...) &&>
+{
+  typedef R type(Args...);
+};
+
+# if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
+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...);
+};
+
+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 Sig0>
+struct are_simple_completion_signatures<Sig0>
+  : is_simple_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 <>
+struct simple_completion_signature<void>
+{
+  typedef void type;
+};
+
+template <typename R>
+struct simple_completion_signature<R()>
+{
+  typedef R type();
+};
+
+#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() &>
+{
+  typedef R type();
+};
+
+template <typename R>
+struct simple_completion_signature<R() &&>
+{
+  typedef R type();
+};
+
+#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>
+{
+  typedef R type();
+};
+
+template <typename R>
+struct simple_completion_signature<R() & noexcept>
+{
+  typedef R type();
+};
+
+template <typename R>
+struct simple_completion_signature<R() && noexcept>
+{
+  typedef R type();
+};
+
+#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>
+class completion_handler_async_result
 {
 public:
-  /// The concrete completion handler type for the specific signature.
   typedef CompletionToken completion_handler_type;
-
-  /// The return type of the initiating function.
   typedef void return_type;
 
-  /// Construct an async result from a given handler.
-  /**
-   * When using a specalised async_result, the constructor has an opportunity
-   * to initialise some state associated with the completion handler, which is
-   * then returned from the initiating function.
-   */
-  explicit async_result(completion_handler_type& h)
+  explicit completion_handler_async_result(completion_handler_type&)
   {
-    (void)h;
   }
 
-  /// Obtain the value to be returned from the initiating function.
   return_type get()
   {
   }
 
-#if defined(GENERATING_DOCUMENTATION)
-
-  /// Initiate the asynchronous operation that will produce the result, and
-  /// 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);
-
-#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
   template <typename Initiation,
-      BOOST_ASIO_COMPLETION_HANDLER_FOR(Signature) RawCompletionToken,
+      BOOST_ASIO_COMPLETION_HANDLER_FOR(Signatures...) RawCompletionToken,
       typename... Args>
   static return_type initiate(
       BOOST_ASIO_MOVE_ARG(Initiation) initiation,
@@ -156,8 +486,7 @@ public:
 
 #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
-  template <typename Initiation,
-      BOOST_ASIO_COMPLETION_HANDLER_FOR(Signature) RawCompletionToken>
+  template <typename Initiation, typename RawCompletionToken>
   static return_type initiate(
       BOOST_ASIO_MOVE_ARG(Initiation) initiation,
       BOOST_ASIO_MOVE_ARG(RawCompletionToken) token)
@@ -168,7 +497,7 @@ public:
 
 #define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
   template <typename Initiation, \
-      BOOST_ASIO_COMPLETION_HANDLER_FOR(Signature) RawCompletionToken, \
+      typename RawCompletionToken, \
       BOOST_ASIO_VARIADIC_TPARAMS(n)> \
   static return_type initiate( \
       BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
@@ -185,31 +514,141 @@ public:
 
 #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
+private:
+  completion_handler_async_result(
+      const completion_handler_async_result&) BOOST_ASIO_DELETED;
+  completion_handler_async_result& operator=(
+      const completion_handler_async_result&) BOOST_ASIO_DELETED;
+};
+
+} // namespace detail
+
+#if defined(GENERATING_DOCUMENTATION)
+
+/// An interface for customising the behaviour of an initiating function.
+/**
+ * The async_result traits class is used for determining:
+ *
+ * @li the concrete completion handler type to be called at the end of the
+ * asynchronous operation;
+ *
+ * @li the initiating function return type; and
+ *
+ * @li how the return value of the initiating function is obtained.
+ *
+ * The trait allows the handler and return types to be determined at the point
+ * where the specific completion handler signature is known.
+ *
+ * This template may be specialised for user-defined completion token types.
+ * The primary template assumes that the CompletionToken is the completion
+ * handler.
+ */
+template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
+class async_result
+{
+public:
+  /// The concrete completion handler type for the specific signature.
+  typedef CompletionToken completion_handler_type;
+
+  /// The return type of the initiating function.
+  typedef void return_type;
+
+  /// Construct an async result from a given handler.
+  /**
+   * When using a specalised async_result, the constructor has an opportunity
+   * to initialise some state associated with the completion handler, which is
+   * then returned from the initiating function.
+   */
+  explicit async_result(completion_handler_type& h);
+
+  /// Obtain the value to be returned from the initiating function.
+  return_type get();
+
+  /// Initiate the asynchronous operation that will produce the result, and
+  /// 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);
+
 private:
   async_result(const async_result&) BOOST_ASIO_DELETED;
   async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
 };
 
-#if !defined(GENERATING_DOCUMENTATION)
+#else // defined(GENERATING_DOCUMENTATION)
 
-template <BOOST_ASIO_COMPLETION_SIGNATURE Signature>
-class async_result<void, Signature>
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
+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>,
+      async_result<CompletionToken,
+        BOOST_ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS>
+    >::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>,
+      async_result<CompletionToken,
+        BOOST_ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS>
+    >::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;
+};
+
+#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>
 {
   // Empty.
 };
 
-#endif // !defined(GENERATING_DOCUMENTATION)
+#endif // defined(GENERATING_DOCUMENTATION)
 
 /// 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_SIGNATURE Signature>
+template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
 struct async_completion
 {
   /// The real handler type to be used for the asynchronous operation.
   typedef typename boost::asio::async_result<
     typename decay<CompletionToken>::type,
-      Signature>::completion_handler_type completion_handler_type;
+      BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>::completion_handler_type
+        completion_handler_type;
 
 #if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
   /// Constructor.
@@ -248,14 +687,16 @@ struct async_completion
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// The result of the asynchronous operation's initiating function.
-  async_result<typename decay<CompletionToken>::type, Signature> result;
+  async_result<typename decay<CompletionToken>::type,
+    BOOST_ASIO_COMPLETION_SIGNATURES_TARGS> result;
 };
 
 namespace detail {
 
-template <typename CompletionToken, typename Signature>
+template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
 struct async_result_helper
-  : async_result<typename decay<CompletionToken>::type, Signature>
+  : async_result<typename decay<CompletionToken>::type,
+      BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>
 {
 };
 
@@ -284,10 +725,11 @@ char async_result_initiate_memfn_helper(
       void (async_result_memfns_base::*)(),
       &async_result_memfns_derived<T>::initiate>*);
 
-template <typename CompletionToken, typename Signature>
+template <typename CompletionToken, BOOST_ASIO_COMPLETION_SIGNATURES_TPARAMS>
 struct async_result_has_initiate_memfn
   : integral_constant<bool, sizeof(async_result_initiate_memfn_helper<
-      async_result<typename decay<CompletionToken>::type, Signature>
+      async_result<typename decay<CompletionToken>::type,
+        BOOST_ASIO_COMPLETION_SIGNATURES_TARGS>
     >(0)) != 1>
 {
 };
@@ -297,48 +739,102 @@ struct async_result_has_initiate_memfn
 #if defined(GENERATING_DOCUMENTATION)
 # define BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig) \
   void_or_deduced
+# define BOOST_ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) \
+  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< \
     typename ::boost::asio::decay<ct>::type, sig>::return_type
+# define BOOST_ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) \
+  typename ::boost::asio::async_result< \
+    typename ::boost::asio::decay<ct>::type, sig0, sig1>::return_type
+# define BOOST_ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) \
+  typename ::boost::asio::async_result< \
+    typename ::boost::asio::decay<ct>::type, sig0, sig1, sig2>::return_type
 #define BOOST_ASIO_HANDLER_TYPE(ct, sig) \
   typename ::boost::asio::async_result< \
     typename ::boost::asio::decay<ct>::type, sig>::completion_handler_type
+#define BOOST_ASIO_HANDLER_TYPE2(ct, sig0, sig1) \
+  typename ::boost::asio::async_result< \
+    typename ::boost::asio::decay<ct>::type, \
+      sig0, sig1>::completion_handler_type
+#define BOOST_ASIO_HANDLER_TYPE3(ct, sig0, sig1, sig2) \
+  typename ::boost::asio::async_result< \
+    typename ::boost::asio::decay<ct>::type, \
+      sig0, sig1, sig2>::completion_handler_type
 #endif
 
 #if defined(GENERATING_DOCUMENTATION)
 # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \
   auto
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE2(ct, sig0, sig1) \
+  auto
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE3(ct, sig0, sig1, sig2) \
+  auto
 #elif defined(BOOST_ASIO_HAS_RETURN_TYPE_DEDUCTION)
 # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \
   auto
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE2(ct, sig0, sig1) \
+  auto
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE3(ct, sig0, sig1, sig2) \
+  auto
 #else
 # define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \
   BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig)
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE2(ct, sig0, sig1) \
+  BOOST_ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1)
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE3(ct, sig0, sig1, sig2) \
+  BOOST_ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2)
 #endif
 
 #if defined(GENERATING_DOCUMENTATION)
 # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \
   void_or_deduced
+# define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE2(ct, sig0, sig1, expr) \
+  void_or_deduced
+# define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE3(ct, sig0, sig1, sig2, expr) \
+  void_or_deduced
 #elif defined(BOOST_ASIO_HAS_DECLTYPE)
 # 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)
 
 template <typename CompletionToken,
-    completion_signature Signature,
+    completion_signature... Signatures,
     typename Initiation, typename... Args>
 void_or_deduced async_initiate(
     BOOST_ASIO_MOVE_ARG(Initiation) initiation,
@@ -348,13 +844,14 @@ void_or_deduced async_initiate(
 #elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename CompletionToken,
-    BOOST_ASIO_COMPLETION_SIGNATURE Signature,
+    BOOST_ASIO_COMPLETION_SIGNATURE... Signatures,
     typename Initiation, typename... Args>
 inline typename constraint<
-    detail::async_result_has_initiate_memfn<CompletionToken, Signature>::value,
-    BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, Signature,
+    detail::async_result_has_initiate_memfn<
+      CompletionToken, Signatures...>::value,
+    BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, Signatures...,
       (async_result<typename decay<CompletionToken>::type,
-        Signature>::initiate(declval<BOOST_ASIO_MOVE_ARG(Initiation)>(),
+        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,
@@ -362,26 +859,27 @@ async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
     BOOST_ASIO_MOVE_ARG(Args)... args)
 {
   return async_result<typename decay<CompletionToken>::type,
-    Signature>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
+    Signatures...>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
       BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
       BOOST_ASIO_MOVE_CAST(Args)(args)...);
 }
 
 template <typename CompletionToken,
-    BOOST_ASIO_COMPLETION_SIGNATURE Signature,
+    BOOST_ASIO_COMPLETION_SIGNATURE... Signatures,
     typename Initiation, typename... Args>
 inline typename constraint<
-    !detail::async_result_has_initiate_memfn<CompletionToken, Signature>::value,
-    BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Signature)>::type
+    !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)
 {
-  async_completion<CompletionToken, Signature> completion(token);
+  async_completion<CompletionToken, Signatures...> completion(token);
 
   BOOST_ASIO_MOVE_CAST(Initiation)(initiation)(
       BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(CompletionToken,
-        Signature))(completion.completion_handler),
+        Signatures...))(completion.completion_handler),
       BOOST_ASIO_MOVE_CAST(Args)(args)...);
 
   return completion.result.get();
@@ -390,50 +888,159 @@ async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
 #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename CompletionToken,
-    BOOST_ASIO_COMPLETION_SIGNATURE Signature,
+    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, Signature>::value,
-    BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, Signature,
+    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,
-        Signature>::initiate(declval<BOOST_ASIO_MOVE_ARG(Initiation)>(),
+        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,
-    Signature>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
+    Sig0, Sig1>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
       BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
 }
 
 template <typename CompletionToken,
-    BOOST_ASIO_COMPLETION_SIGNATURE Signature,
+    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, Signature>::value,
-    BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Signature)>::type
+    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)
 {
-  async_completion<CompletionToken, Signature> completion(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,
-        Signature))(completion.completion_handler));
+        Sig0))(completion.completion_handler));
+
+  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();
 }
 
 #define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
   template <typename CompletionToken, \
-      BOOST_ASIO_COMPLETION_SIGNATURE Signature, \
+      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, Signature>::value, \
-      BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, Signature, \
+        CompletionToken, Sig0, Sig1>::value, \
+      BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE2( \
+        CompletionToken, Sig0, Sig1, \
         (async_result<typename decay<CompletionToken>::type, \
-          Signature>::initiate(declval<BOOST_ASIO_MOVE_ARG(Initiation)>(), \
+          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, \
@@ -441,27 +1048,102 @@ async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
       BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
   { \
     return async_result<typename decay<CompletionToken>::type, \
-      Signature>::initiate(BOOST_ASIO_MOVE_CAST(Initiation)(initiation), \
+      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 Signature, \
+      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, Signature>::value, \
-      BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, Signature)>::type \
+        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, Signature> completion(token); \
+    async_completion<CompletionToken, \
+      Sig0> completion(token); \
   \
     BOOST_ASIO_MOVE_CAST(Initiation)(initiation)( \
         BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(CompletionToken, \
-          Signature))(completion.completion_handler), \
+          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(); \
@@ -478,10 +1160,10 @@ async_initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
 
 namespace detail {
 
-template <typename Signature>
+template <typename... Signatures>
 struct initiation_archetype
 {
-  template <completion_handler_for<Signature> CompletionHandler>
+  template <completion_handler_for<Signatures...> CompletionHandler>
   void operator()(CompletionHandler&&) const
   {
   }
@@ -489,23 +1171,30 @@ struct initiation_archetype
 
 } // namespace detail
 
-template <typename T, typename Signature>
+template <typename T, typename... Signatures>
 BOOST_ASIO_CONCEPT completion_token_for =
-  detail::is_completion_signature<Signature>::value
+  detail::are_completion_signatures<Signatures...>::value
   &&
   requires(T&& t)
   {
-    async_initiate<T, Signature>(detail::initiation_archetype<Signature>{}, t);
+    async_initiate<T, Signatures...>(
+        detail::initiation_archetype<Signatures...>{}, t);
   };
 
-#define BOOST_ASIO_COMPLETION_TOKEN_FOR(s) \
-  ::boost::asio::completion_token_for<s>
+#define BOOST_ASIO_COMPLETION_TOKEN_FOR(sig) \
+  ::boost::asio::completion_token_for<sig>
+#define BOOST_ASIO_COMPLETION_TOKEN_FOR2(sig0, sig1) \
+  ::boost::asio::completion_token_for<sig0, sig1>
+#define BOOST_ASIO_COMPLETION_TOKEN_FOR3(sig0, sig1, sig2) \
+  ::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(s) typename
+#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)
diff --git a/boost/asio/awaitable.hpp b/boost/asio/awaitable.hpp
index e4177234353ee9148b950d16b297317543c42f3e..7501989952c697c9dc0346cab9dd67d7ed842858 100644
--- a/boost/asio/awaitable.hpp
+++ b/boost/asio/awaitable.hpp
@@ -2,7 +2,7 @@
 // awaitable.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -25,6 +25,7 @@
 # include <experimental/coroutine>
 #endif // defined(BOOST_ASIO_HAS_STD_COROUTINE)
 
+#include <utility>
 #include <boost/asio/any_io_executor.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -48,7 +49,7 @@ template <typename, typename> class awaitable_frame;
 
 /// The return type of a coroutine or asynchronous operation.
 template <typename T, typename Executor = any_io_executor>
-class awaitable
+class BOOST_ASIO_NODISCARD awaitable
 {
 public:
   /// The type of the awaited value.
@@ -76,6 +77,14 @@ public:
       frame_->destroy();
   }
 
+  /// Move assignment.
+  awaitable& operator=(awaitable&& other) noexcept
+  {
+    if (this != &other)
+      frame_ = std::exchange(other.frame_, nullptr);
+    return *this;
+  }
+
   /// Checks if the awaitable refers to a future result.
   bool valid() const noexcept
   {
diff --git a/boost/asio/basic_datagram_socket.hpp b/boost/asio/basic_datagram_socket.hpp
index 3b6319a3adc7b6908625d350d1dee5623e66e994..bd4b952a3d94936a33d92d78a5e36874ea2e237b 100644
--- a/boost/asio/basic_datagram_socket.hpp
+++ b/boost/asio/basic_datagram_socket.hpp
@@ -2,7 +2,7 @@
 // basic_datagram_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -424,25 +424,31 @@ public:
   /// Start an asynchronous send on a connected socket.
   /**
    * This function is used to asynchronously send data on the datagram socket.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected datagram
    * socket.
@@ -455,65 +461,91 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(this), handler,
+        initiate_async_send(this), token,
         buffers, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous send on a connected socket.
   /**
    * This function is used to asynchronously send data on the datagram socket.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected datagram
    * socket.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(this), handler, buffers, flags);
+        initiate_async_send(this), token, buffers, flags);
   }
 
   /// Send a datagram to the specified endpoint.
@@ -607,28 +639,34 @@ public:
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send a datagram to the specified
-   * remote endpoint. The function call always returns immediately.
+   * remote endpoint. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param destination The remote endpoint to which the data will be sent.
    * Copies will be made of the endpoint as required.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
@@ -640,65 +678,91 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send_to(this), handler, buffers,
+        initiate_async_send_to(this), token, buffers,
         destination, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send a datagram to the specified
-   * remote endpoint. The function call always returns immediately.
+   * remote endpoint. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param destination The remote endpoint to which the data will be sent.
    * Copies will be made of the endpoint as required.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send_to(this), handler, buffers, destination, flags);
+        initiate_async_send_to(this), token, buffers, destination, flags);
   }
 
   /// Receive some data on a connected socket.
@@ -793,25 +857,31 @@ public:
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the datagram
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
    * datagram socket.
@@ -825,65 +895,91 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(this), handler,
+        initiate_async_receive(this), token,
         buffers, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the datagram
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
    * datagram socket.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(this), handler, buffers, flags);
+        initiate_async_receive(this), token, buffers, flags);
   }
 
   /// Receive a datagram with the endpoint of the sender.
@@ -977,31 +1073,37 @@ public:
 
   /// Start an asynchronous receive.
   /**
-   * This function is used to asynchronously receive a datagram. The function
-   * call always returns immediately.
+   * This function is used to asynchronously receive a datagram. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the datagram. Ownership of the sender_endpoint object
    * is retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
+   * completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
@@ -1010,67 +1112,93 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive_from(this), handler, buffers,
+        initiate_async_receive_from(this), token, buffers,
         &sender_endpoint, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous receive.
   /**
-   * This function is used to asynchronously receive a datagram. The function
-   * call always returns immediately.
+   * This function is used to asynchronously receive a datagram. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the datagram. Ownership of the sender_endpoint object
    * is retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
+   * completion handler is called.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive_from(this), handler,
+        initiate_async_receive_from(this), token,
         buffers, &sender_endpoint, flags);
   }
 
diff --git a/boost/asio/basic_deadline_timer.hpp b/boost/asio/basic_deadline_timer.hpp
index cc5ea6b4920c91fede5788bc34cc676c936d3f8d..1676dba75172205ca466e3365cbce9c437a2371d 100644
--- a/boost/asio/basic_deadline_timer.hpp
+++ b/boost/asio/basic_deadline_timer.hpp
@@ -2,7 +2,7 @@
 // basic_deadline_timer.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -608,38 +608,54 @@ public:
   /// Start an asynchronous wait on the timer.
   /**
    * This function may be used to initiate an asynchronous wait against the
-   * timer. It always returns immediately.
+   * timer. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
-   * For each call to async_wait(), the supplied handler will be called exactly
-   * once. The handler will be called when:
+   * For each call to async_wait(), the completion handler will be called
+   * exactly once. The completion handler will be called when:
    *
    * @li The timer has expired.
    *
    * @li The timer was cancelled, in which case the handler is passed the error
    * code boost::asio::error::operation_aborted.
    *
-   * @param handler The handler to be called when the timer expires. Copies
-   * will be made of the handler as required. The function signature of the
-   * handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the timer expires. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
-        WaitHandler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitHandler,
+        WaitToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitToken,
       void (boost::system::error_code))
   async_wait(
-      BOOST_ASIO_MOVE_ARG(WaitHandler) handler
+      BOOST_ASIO_MOVE_ARG(WaitToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WaitHandler, void (boost::system::error_code)>(
-        initiate_async_wait(this), handler);
+    return async_initiate<WaitToken, void (boost::system::error_code)>(
+        initiate_async_wait(this), token);
   }
 
 private:
diff --git a/boost/asio/basic_file.hpp b/boost/asio/basic_file.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..fb862994da3a038ffdb312a88c569438986132db
--- /dev/null
+++ b/boost/asio/basic_file.hpp
@@ -0,0 +1,831 @@
+//
+// basic_file.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_FILE_HPP
+#define BOOST_ASIO_BASIC_FILE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_FILE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <string>
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/cstdint.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/io_object_impl.hpp>
+#include <boost/asio/detail/non_const_lvalue.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/post.hpp>
+#include <boost/asio/file_base.hpp>
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/win_iocp_file_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IO_URING)
+# include <boost/asio/detail/io_uring_file_service.hpp>
+#endif
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+#if !defined(BOOST_ASIO_BASIC_FILE_FWD_DECL)
+#define BOOST_ASIO_BASIC_FILE_FWD_DECL
+
+// Forward declaration with defaulted arguments.
+template <typename Executor = any_io_executor>
+class basic_file;
+
+#endif // !defined(BOOST_ASIO_BASIC_FILE_FWD_DECL)
+
+/// Provides file functionality.
+/**
+ * The basic_file class template provides functionality that is common to both
+ * stream-oriented and random-access files.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <typename Executor>
+class basic_file
+  : public file_base
+{
+public:
+  /// The type of the executor associated with the object.
+  typedef Executor executor_type;
+
+  /// Rebinds the file type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The file type when rebound to the specified executor.
+    typedef basic_file<Executor1> other;
+  };
+
+  /// The native representation of a file.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::win_iocp_file_service::native_handle_type native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IO_URING)
+  typedef detail::io_uring_file_service::native_handle_type native_handle_type;
+#endif
+
+  /// Construct a basic_file without opening it.
+  /**
+   * This constructor initialises a file without opening it.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   */
+  explicit basic_file(const executor_type& ex)
+    : impl_(0, ex)
+  {
+  }
+
+  /// Construct a basic_file without opening it.
+  /**
+   * This constructor initialises a file without opening it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   */
+  template <typename ExecutionContext>
+  explicit basic_file(ExecutionContext& context,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
+  {
+  }
+
+  /// Construct and open a basic_file.
+  /**
+   * This constructor initialises a file and opens it.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   */
+  explicit basic_file(const executor_type& ex,
+      const char* path, file_base::flags open_flags)
+    : impl_(0, ex)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct a basic_file without opening it.
+  /**
+   * This constructor initialises a file and opens it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   */
+  template <typename ExecutionContext>
+  explicit basic_file(ExecutionContext& context,
+      const char* path, file_base::flags open_flags,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct and open a basic_file.
+  /**
+   * This constructor initialises a file and opens it.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   */
+  explicit basic_file(const executor_type& ex,
+      const std::string& path, file_base::flags open_flags)
+    : impl_(0, ex)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().open(impl_.get_implementation(),
+        path.c_str(), open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct a basic_file without opening it.
+  /**
+   * This constructor initialises a file and opens it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   */
+  template <typename ExecutionContext>
+  explicit basic_file(ExecutionContext& context,
+      const std::string& path, file_base::flags open_flags,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().open(impl_.get_implementation(),
+        path.c_str(), open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct a basic_file on an existing native file handle.
+  /**
+   * This constructor initialises a file object to hold an existing native file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param native_file A native file handle.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_file(const executor_type& ex, const native_handle_type& native_file)
+    : impl_(0, ex)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(
+        impl_.get_implementation(), native_file, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Construct a basic_file on an existing native file.
+  /**
+   * This constructor initialises a file object to hold an existing native file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param native_file A native file.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_file(ExecutionContext& context, const native_handle_type& native_file,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(
+        impl_.get_implementation(), native_file, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_file from another.
+  /**
+   * This constructor moves a file from one object to another.
+   *
+   * @param other The other basic_file object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_file(const executor_type&) constructor.
+   */
+  basic_file(basic_file&& other) BOOST_ASIO_NOEXCEPT
+    : impl_(std::move(other.impl_))
+  {
+  }
+
+  /// Move-assign a basic_file from another.
+  /**
+   * This assignment operator moves a file from one object to another.
+   *
+   * @param other The other basic_file object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_file(const executor_type&) constructor.
+   */
+  basic_file& operator=(basic_file&& other)
+  {
+    impl_ = std::move(other.impl_);
+    return *this;
+  }
+
+  // All files have access to each other's implementations.
+  template <typename Executor1>
+  friend class basic_file;
+
+  /// Move-construct a basic_file from a file of another executor type.
+  /**
+   * This constructor moves a file from one object to another.
+   *
+   * @param other The other basic_file object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_file(const executor_type&) constructor.
+   */
+  template <typename Executor1>
+  basic_file(basic_file<Executor1>&& other,
+      typename constraint<
+        is_convertible<Executor1, Executor>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(std::move(other.impl_))
+  {
+  }
+
+  /// Move-assign a basic_file from a file of another executor type.
+  /**
+   * This assignment operator moves a file from one object to another.
+   *
+   * @param other The other basic_file object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_file(const executor_type&) constructor.
+   */
+  template <typename Executor1>
+  typename constraint<
+    is_convertible<Executor1, Executor>::value,
+    basic_file&
+  >::type operator=(basic_file<Executor1> && other)
+  {
+    basic_file tmp(std::move(other));
+    impl_ = std::move(tmp.impl_);
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() BOOST_ASIO_NOEXCEPT
+  {
+    return impl_.get_executor();
+  }
+
+  /// Open the file using the specified path.
+  /**
+   * This function opens the file so that it will use the specified path.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @par Example
+   * @code
+   * boost::asio::stream_file file(my_context);
+   * file.open("/path/to/my/file", boost::asio::stream_file::read_only);
+   * @endcode
+   */
+  void open(const char* path, file_base::flags open_flags)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Open the file using the specified path.
+  /**
+   * This function opens the file so that it will use the specified path.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @par Example
+   * @code
+   * boost::asio::stream_file file(my_context);
+   * boost::system::error_code ec;
+   * file.open("/path/to/my/file", boost::asio::stream_file::read_only, ec);
+   * if (ec)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  BOOST_ASIO_SYNC_OP_VOID open(const char* path,
+      file_base::flags open_flags, boost::system::error_code& ec)
+  {
+    impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Open the file using the specified path.
+  /**
+   * This function opens the file so that it will use the specified path.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @par Example
+   * @code
+   * boost::asio::stream_file file(my_context);
+   * file.open("/path/to/my/file", boost::asio::stream_file::read_only);
+   * @endcode
+   */
+  void open(const std::string& path, file_base::flags open_flags)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().open(impl_.get_implementation(),
+        path.c_str(), open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Open the file using the specified path.
+  /**
+   * This function opens the file so that it will use the specified path.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @par Example
+   * @code
+   * boost::asio::stream_file file(my_context);
+   * boost::system::error_code ec;
+   * file.open("/path/to/my/file", boost::asio::stream_file::read_only, ec);
+   * if (ec)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  BOOST_ASIO_SYNC_OP_VOID open(const std::string& path,
+      file_base::flags open_flags, boost::system::error_code& ec)
+  {
+    impl_.get_service().open(impl_.get_implementation(),
+        path.c_str(), open_flags, ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Assign an existing native file to the file.
+  /*
+   * This function opens the file to hold an existing native file.
+   *
+   * @param native_file A native file.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void assign(const native_handle_type& native_file)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(
+        impl_.get_implementation(), native_file, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Assign an existing native file to the file.
+  /*
+   * This function opens the file to hold an existing native file.
+   *
+   * @param native_file A native file.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID assign(const native_handle_type& native_file,
+      boost::system::error_code& ec)
+  {
+    impl_.get_service().assign(
+        impl_.get_implementation(), native_file, ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Determine whether the file is open.
+  bool is_open() const
+  {
+    return impl_.get_service().is_open(impl_.get_implementation());
+  }
+
+  /// Close the file.
+  /**
+   * This function is used to close the file. Any asynchronous read or write
+   * operations will be cancelled immediately, and will complete with the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @throws boost::system::system_error Thrown on failure. Note that, even if
+   * the function indicates an error, the underlying descriptor is closed.
+   */
+  void close()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().close(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "close");
+  }
+
+  /// Close the file.
+  /**
+   * This function is used to close the file. Any asynchronous read or write
+   * operations will be cancelled immediately, and will complete with the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any. Note that, even if
+   * the function indicates an error, the underlying descriptor is closed.
+   *
+   * @par Example
+   * @code
+   * boost::asio::stream_file file(my_context);
+   * ...
+   * boost::system::error_code ec;
+   * file.close(ec);
+   * if (ec)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  BOOST_ASIO_SYNC_OP_VOID close(boost::system::error_code& ec)
+  {
+    impl_.get_service().close(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Release ownership of the underlying native file.
+  /**
+   * This function causes all outstanding asynchronous read and write
+   * operations to finish immediately, and the handlers for cancelled
+   * operations will be passed the boost::asio::error::operation_aborted error.
+   * Ownership of the native file is then transferred to the caller.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note This function is unsupported on Windows versions prior to Windows
+   * 8.1, and will fail with boost::asio::error::operation_not_supported on
+   * these platforms.
+   */
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
+  __declspec(deprecated("This function always fails with "
+        "operation_not_supported when used on Windows versions "
+        "prior to Windows 8.1."))
+#endif
+  native_handle_type release()
+  {
+    boost::system::error_code ec;
+    native_handle_type s = impl_.get_service().release(
+        impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "release");
+    return s;
+  }
+
+  /// Release ownership of the underlying native file.
+  /**
+   * This function causes all outstanding asynchronous read and write
+   * operations to finish immediately, and the handlers for cancelled
+   * operations will be passed the boost::asio::error::operation_aborted error.
+   * Ownership of the native file is then transferred to the caller.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note This function is unsupported on Windows versions prior to Windows
+   * 8.1, and will fail with boost::asio::error::operation_not_supported on
+   * these platforms.
+   */
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
+  __declspec(deprecated("This function always fails with "
+        "operation_not_supported when used on Windows versions "
+        "prior to Windows 8.1."))
+#endif
+  native_handle_type release(boost::system::error_code& ec)
+  {
+    return impl_.get_service().release(impl_.get_implementation(), ec);
+  }
+
+  /// Get the native file representation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * file. This is intended to allow access to native file functionality
+   * that is not otherwise provided.
+   */
+  native_handle_type native_handle()
+  {
+    return impl_.get_service().native_handle(impl_.get_implementation());
+  }
+
+  /// Cancel all asynchronous operations associated with the file.
+  /**
+   * This function causes all outstanding asynchronous read and write
+   * operations to finish immediately, and the handlers for cancelled
+   * operations will be passed the boost::asio::error::operation_aborted error.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   *
+   * @note Calls to cancel() will always fail with
+   * boost::asio::error::operation_not_supported when run on Windows XP, Windows
+   * Server 2003, and earlier versions of Windows, unless
+   * BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
+   * two issues that should be considered before enabling its use:
+   *
+   * @li It will only cancel asynchronous operations that were initiated in the
+   * current thread.
+   *
+   * @li It can appear to complete without error, but the request to cancel the
+   * unfinished operations may be silently ignored by the operating system.
+   * Whether it works or not seems to depend on the drivers that are installed.
+   *
+   * For portable cancellation, consider using the close() function to
+   * simultaneously cancel the outstanding operations and close the file.
+   *
+   * When running on Windows Vista, Windows Server 2008, and later, the
+   * CancelIoEx function is always used. This function does not have the
+   * problems described above.
+   */
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \
+  && !defined(BOOST_ASIO_ENABLE_CANCELIO)
+  __declspec(deprecated("By default, this function always fails with "
+        "operation_not_supported when used on Windows XP, Windows Server 2003, "
+        "or earlier. Consult documentation for details."))
+#endif
+  void cancel()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().cancel(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "cancel");
+  }
+
+  /// Cancel all asynchronous operations associated with the file.
+  /**
+   * This function causes all outstanding asynchronous read and write
+   * operations to finish immediately, and the handlers for cancelled
+   * operations will be passed the boost::asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @note Calls to cancel() will always fail with
+   * boost::asio::error::operation_not_supported when run on Windows XP, Windows
+   * Server 2003, and earlier versions of Windows, unless
+   * BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
+   * two issues that should be considered before enabling its use:
+   *
+   * @li It will only cancel asynchronous operations that were initiated in the
+   * current thread.
+   *
+   * @li It can appear to complete without error, but the request to cancel the
+   * unfinished operations may be silently ignored by the operating system.
+   * Whether it works or not seems to depend on the drivers that are installed.
+   *
+   * For portable cancellation, consider using the close() function to
+   * simultaneously cancel the outstanding operations and close the file.
+   *
+   * When running on Windows Vista, Windows Server 2008, and later, the
+   * CancelIoEx function is always used. This function does not have the
+   * problems described above.
+   */
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
+  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \
+  && !defined(BOOST_ASIO_ENABLE_CANCELIO)
+  __declspec(deprecated("By default, this function always fails with "
+        "operation_not_supported when used on Windows XP, Windows Server 2003, "
+        "or earlier. Consult documentation for details."))
+#endif
+  BOOST_ASIO_SYNC_OP_VOID cancel(boost::system::error_code& ec)
+  {
+    impl_.get_service().cancel(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Get the size of the file.
+  /**
+   * This function determines the size of the file, in bytes.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  uint64_t size() const
+  {
+    boost::system::error_code ec;
+    uint64_t s = impl_.get_service().size(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "size");
+    return s;
+  }
+
+  /// Get the size of the file.
+  /**
+   * This function determines the size of the file, in bytes.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  uint64_t size(boost::system::error_code& ec) const
+  {
+    return impl_.get_service().size(impl_.get_implementation(), ec);
+  }
+
+  /// Alter the size of the file.
+  /**
+   * This function resizes the file to the specified size, in bytes. If the
+   * current file size exceeds @c n then any extra data is discarded. If the
+   * current size is less than @c n then the file is extended and filled with
+   * zeroes.
+   *
+   * @param n The new size for the file.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void resize(uint64_t n)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().resize(impl_.get_implementation(), n, ec);
+    boost::asio::detail::throw_error(ec, "resize");
+  }
+
+  /// Alter the size of the file.
+  /**
+   * This function resizes the file to the specified size, in bytes. If the
+   * current file size exceeds @c n then any extra data is discarded. If the
+   * current size is less than @c n then the file is extended and filled with
+   * zeroes.
+   *
+   * @param n The new size for the file.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID resize(uint64_t n, boost::system::error_code& ec)
+  {
+    impl_.get_service().resize(impl_.get_implementation(), n, ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Synchronise the file to disk.
+  /**
+   * This function synchronises the file data and metadata to disk. Note that
+   * the semantics of this synchronisation vary between operation systems.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void sync_all()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().sync_all(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "sync_all");
+  }
+
+  /// Synchronise the file to disk.
+  /**
+   * This function synchronises the file data and metadata to disk. Note that
+   * the semantics of this synchronisation vary between operation systems.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID sync_all(boost::system::error_code& ec)
+  {
+    impl_.get_service().sync_all(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Synchronise the file data to disk.
+  /**
+   * This function synchronises the file data to disk. Note that the semantics
+   * of this synchronisation vary between operation systems.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void sync_data()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().sync_data(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "sync_data");
+  }
+
+  /// Synchronise the file data to disk.
+  /**
+   * This function synchronises the file data to disk. Note that the semantics
+   * of this synchronisation vary between operation systems.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID sync_data(boost::system::error_code& ec)
+  {
+    impl_.get_service().sync_data(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  /**
+   * This function destroys the file, cancelling any outstanding asynchronous
+   * operations associated with the file as if by calling @c cancel.
+   */
+  ~basic_file()
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+  detail::io_object_impl<detail::win_iocp_file_service, Executor> impl_;
+#elif defined(BOOST_ASIO_HAS_IO_URING)
+  detail::io_object_impl<detail::io_uring_file_service, Executor> impl_;
+#endif
+
+private:
+  // Disallow copying and assignment.
+  basic_file(const basic_file&) BOOST_ASIO_DELETED;
+  basic_file& operator=(const basic_file&) BOOST_ASIO_DELETED;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_BASIC_FILE_HPP
diff --git a/boost/asio/basic_io_object.hpp b/boost/asio/basic_io_object.hpp
index 97b26b12dce3a01b81fcbbb527e6e3c25a62d50d..ff6321d49793c4138e81e7302a520eb0606ac9b0 100644
--- a/boost/asio/basic_io_object.hpp
+++ b/boost/asio/basic_io_object.hpp
@@ -2,7 +2,7 @@
 // basic_io_object.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/basic_random_access_file.hpp b/boost/asio/basic_random_access_file.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..248eb0aea14380a161a15c5c4181c5db3a8ec78e
--- /dev/null
+++ b/boost/asio/basic_random_access_file.hpp
@@ -0,0 +1,691 @@
+//
+// basic_random_access_file.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_RANDOM_ACCESS_FILE_HPP
+#define BOOST_ASIO_BASIC_RANDOM_ACCESS_FILE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_FILE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <cstddef>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/basic_file.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/non_const_lvalue.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+#if !defined(BOOST_ASIO_BASIC_RANDOM_ACCESS_FILE_FWD_DECL)
+#define BOOST_ASIO_BASIC_RANDOM_ACCESS_FILE_FWD_DECL
+
+// Forward declaration with defaulted arguments.
+template <typename Executor = any_io_executor>
+class basic_random_access_file;
+
+#endif // !defined(BOOST_ASIO_BASIC_RANDOM_ACCESS_FILE_FWD_DECL)
+
+/// Provides random-access file functionality.
+/**
+ * The basic_random_access_file class template provides asynchronous and
+ * blocking random-access file functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * Synchronous @c read_some_at and @c write_some_at operations are thread safe
+ * with respect to each other, if the underlying operating system calls are
+ * also thread safe. This means that it is permitted to perform concurrent
+ * calls to these synchronous operations on a single file object. Other
+ * synchronous operations, such as @c open or @c close, are not thread safe.
+ */
+template <typename Executor>
+class basic_random_access_file
+  : public basic_file<Executor>
+{
+public:
+  /// The type of the executor associated with the object.
+  typedef Executor executor_type;
+
+  /// Rebinds the file type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The file type when rebound to the specified executor.
+    typedef basic_random_access_file<Executor1> other;
+  };
+
+  /// The native representation of a file.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename basic_file<Executor>::native_handle_type native_handle_type;
+#endif
+
+  /// Construct a basic_random_access_file without opening it.
+  /**
+   * This constructor initialises a file without opening it. The file needs to
+   * be opened before data can be read from or or written to it.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   */
+  explicit basic_random_access_file(const executor_type& ex)
+    : basic_file<Executor>(ex)
+  {
+  }
+
+  /// Construct a basic_random_access_file without opening it.
+  /**
+   * This constructor initialises a file without opening it. The file needs to
+   * be opened before data can be read from or or written to it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   */
+  template <typename ExecutionContext>
+  explicit basic_random_access_file(ExecutionContext& context,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context)
+  {
+  }
+
+  /// Construct and open a basic_random_access_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_random_access_file(const executor_type& ex,
+      const char* path, file_base::flags open_flags)
+    : basic_file<Executor>(ex, path, open_flags)
+  {
+  }
+
+  /// Construct and open a basic_random_access_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_random_access_file(ExecutionContext& context,
+      const char* path, file_base::flags open_flags,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context, path, open_flags)
+  {
+  }
+
+  /// Construct and open a basic_random_access_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_random_access_file(const executor_type& ex,
+      const std::string& path, file_base::flags open_flags)
+    : basic_file<Executor>(ex, path, open_flags)
+  {
+  }
+
+  /// Construct and open a basic_random_access_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_random_access_file(ExecutionContext& context,
+      const std::string& path, file_base::flags open_flags,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context, path, open_flags)
+  {
+  }
+
+  /// Construct a basic_random_access_file on an existing native file.
+  /**
+   * This constructor initialises a random-access file object to hold an
+   * existing native file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param native_file The new underlying file implementation.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_random_access_file(const executor_type& ex,
+      const native_handle_type& native_file)
+    : basic_file<Executor>(ex, native_file)
+  {
+  }
+
+  /// Construct a basic_random_access_file on an existing native file.
+  /**
+   * This constructor initialises a random-access file object to hold an
+   * existing native file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param native_file The new underlying file implementation.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_random_access_file(ExecutionContext& context,
+      const native_handle_type& native_file,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context, native_file)
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_random_access_file from another.
+  /**
+   * This constructor moves a random-access file from one object to another.
+   *
+   * @param other The other basic_random_access_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_random_access_file(const executor_type&)
+   * constructor.
+   */
+  basic_random_access_file(basic_random_access_file&& other) BOOST_ASIO_NOEXCEPT
+    : basic_file<Executor>(std::move(other))
+  {
+  }
+
+  /// Move-assign a basic_random_access_file from another.
+  /**
+   * This assignment operator moves a random-access file from one object to
+   * another.
+   *
+   * @param other The other basic_random_access_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_random_access_file(const executor_type&)
+   * constructor.
+   */
+  basic_random_access_file& operator=(basic_random_access_file&& other)
+  {
+    basic_file<Executor>::operator=(std::move(other));
+    return *this;
+  }
+
+  /// Move-construct a basic_random_access_file from a file of another executor
+  /// type.
+  /**
+   * This constructor moves a random-access file from one object to another.
+   *
+   * @param other The other basic_random_access_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_random_access_file(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  basic_random_access_file(basic_random_access_file<Executor1>&& other,
+      typename constraint<
+        is_convertible<Executor1, Executor>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(std::move(other))
+  {
+  }
+
+  /// Move-assign a basic_random_access_file from a file of another executor
+  /// type.
+  /**
+   * This assignment operator moves a random-access file from one object to
+   * another.
+   *
+   * @param other The other basic_random_access_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_random_access_file(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  typename constraint<
+    is_convertible<Executor1, Executor>::value,
+    basic_random_access_file&
+  >::type operator=(basic_random_access_file<Executor1>&& other)
+  {
+    basic_file<Executor>::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destroys the file.
+  /**
+   * This function destroys the file, cancelling any outstanding asynchronous
+   * operations associated with the file as if by calling @c cancel.
+   */
+  ~basic_random_access_file()
+  {
+  }
+
+  /// Write some data to the handle at the specified offset.
+  /**
+   * This function is used to write data to the random-access handle. The
+   * function call will block until one or more bytes of the data has been
+   * written successfully, or until an error occurs.
+   *
+   * @param offset The offset at which the data will be written.
+   *
+   * @param buffers One or more data buffers to be written to the handle.
+   *
+   * @returns The number of bytes written.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the end of the file was reached.
+   *
+   * @note The write_some_at operation may not write all of the data. Consider
+   * using the @ref write_at function if you need to ensure that all data is
+   * written before the blocking operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.write_some_at(42, boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on writing multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some_at(uint64_t offset,
+      const ConstBufferSequence& buffers)
+  {
+    boost::system::error_code ec;
+    std::size_t s = this->impl_.get_service().write_some_at(
+        this->impl_.get_implementation(), offset, buffers, ec);
+    boost::asio::detail::throw_error(ec, "write_some_at");
+    return s;
+  }
+
+  /// Write some data to the handle at the specified offset.
+  /**
+   * This function is used to write data to the random-access handle. The
+   * function call will block until one or more bytes of the data has been
+   * written successfully, or until an error occurs.
+   *
+   * @param offset The offset at which the data will be written.
+   *
+   * @param buffers One or more data buffers to be written to the handle.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes written. Returns 0 if an error occurred.
+   *
+   * @note The write_some operation may not write all of the data to the
+   * file. Consider using the @ref write_at function if you need to ensure that
+   * all data is written before the blocking operation completes.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some_at(uint64_t offset,
+      const ConstBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    return this->impl_.get_service().write_some_at(
+        this->impl_.get_implementation(), offset, buffers, ec);
+  }
+
+  /// Start an asynchronous write at the specified offset.
+  /**
+   * This function is used to asynchronously write data to the random-access
+   * handle. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
+   *
+   * @param offset The offset at which the data will be written.
+   *
+   * @param buffers One or more data buffers to be written to the handle.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the completion handler is called.
+   *
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes written.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @note The write operation may not write all of the data to the file.
+   * Consider using the @ref async_write_at function if you need to ensure that
+   * all data is written before the asynchronous operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.async_write_some_at(42, boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on writing multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
+   */
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
+      void (boost::system::error_code, std::size_t))
+  async_write_some_at(uint64_t offset,
+      const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+  {
+    return async_initiate<WriteToken,
+      void (boost::system::error_code, std::size_t)>(
+        initiate_async_write_some_at(this), token, offset, buffers);
+  }
+
+  /// Read some data from the handle at the specified offset.
+  /**
+   * This function is used to read data from the random-access handle. The
+   * function call will block until one or more bytes of data has been read
+   * successfully, or until an error occurs.
+   *
+   * @param offset The offset at which the data will be read.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @returns The number of bytes read.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the end of the file was reached.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read_at function if you need to ensure that
+   * the requested amount of data is read before the blocking operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.read_some_at(42, boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on reading into multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some_at(uint64_t offset,
+      const MutableBufferSequence& buffers)
+  {
+    boost::system::error_code ec;
+    std::size_t s = this->impl_.get_service().read_some_at(
+        this->impl_.get_implementation(), offset, buffers, ec);
+    boost::asio::detail::throw_error(ec, "read_some_at");
+    return s;
+  }
+
+  /// Read some data from the handle at the specified offset.
+  /**
+   * This function is used to read data from the random-access handle. The
+   * function call will block until one or more bytes of data has been read
+   * successfully, or until an error occurs.
+   *
+   * @param offset The offset at which the data will be read.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read_at function if you need to ensure that
+   * the requested amount of data is read before the blocking operation
+   * completes.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some_at(uint64_t offset,
+      const MutableBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    return this->impl_.get_service().read_some_at(
+        this->impl_.get_implementation(), offset, buffers, ec);
+  }
+
+  /// Start an asynchronous read at the specified offset.
+  /**
+   * This function is used to asynchronously read data from the random-access
+   * handle. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
+   *
+   * @param offset The offset at which the data will be read.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the completion handler is called.
+   *
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes read.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @note The read operation may not read all of the requested number of bytes.
+   * Consider using the @ref async_read_at function if you need to ensure that
+   * the requested amount of data is read before the asynchronous operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * handle.async_read_some_at(42, boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on reading into multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
+   */
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
+      void (boost::system::error_code, std::size_t))
+  async_read_some_at(uint64_t offset,
+      const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+  {
+    return async_initiate<ReadToken,
+      void (boost::system::error_code, std::size_t)>(
+        initiate_async_read_some_at(this), token, offset, buffers);
+  }
+
+private:
+  // Disallow copying and assignment.
+  basic_random_access_file(const basic_random_access_file&) BOOST_ASIO_DELETED;
+  basic_random_access_file& operator=(
+      const basic_random_access_file&) BOOST_ASIO_DELETED;
+
+  class initiate_async_write_some_at
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_write_some_at(basic_random_access_file* self)
+      : self_(self)
+    {
+    }
+
+    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename WriteHandler, typename ConstBufferSequence>
+    void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+        uint64_t offset, const ConstBufferSequence& buffers) const
+    {
+      // If you get an error on the following line it means that your handler
+      // does not meet the documented type requirements for a WriteHandler.
+      BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+      detail::non_const_lvalue<WriteHandler> handler2(handler);
+      self_->impl_.get_service().async_write_some_at(
+          self_->impl_.get_implementation(), offset, buffers,
+          handler2.value, self_->impl_.get_executor());
+    }
+
+  private:
+    basic_random_access_file* self_;
+  };
+
+  class initiate_async_read_some_at
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_read_some_at(basic_random_access_file* self)
+      : self_(self)
+    {
+    }
+
+    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename ReadHandler, typename MutableBufferSequence>
+    void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+        uint64_t offset, const MutableBufferSequence& buffers) const
+    {
+      // If you get an error on the following line it means that your handler
+      // does not meet the documented type requirements for a ReadHandler.
+      BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+      detail::non_const_lvalue<ReadHandler> handler2(handler);
+      self_->impl_.get_service().async_read_some_at(
+          self_->impl_.get_implementation(), offset, buffers,
+          handler2.value, self_->impl_.get_executor());
+    }
+
+  private:
+    basic_random_access_file* self_;
+  };
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_BASIC_RANDOM_ACCESS_FILE_HPP
diff --git a/boost/asio/basic_raw_socket.hpp b/boost/asio/basic_raw_socket.hpp
index 861c83aa9df880f20572b576abb38413c7620e27..e1f3a513c62880966c8bd544f814a38cbf257efc 100644
--- a/boost/asio/basic_raw_socket.hpp
+++ b/boost/asio/basic_raw_socket.hpp
@@ -2,7 +2,7 @@
 // basic_raw_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -415,26 +415,32 @@ public:
 
   /// Start an asynchronous send on a connected socket.
   /**
-   * This function is used to send data on the raw socket. The function call
-   * will block until the data has been sent successfully or an error occurs.
+   * This function is used to asynchronously send data on the raw socket. It is
+   * an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected raw
    * socket.
@@ -447,65 +453,91 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(this), handler,
+        initiate_async_send(this), token,
         buffers, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous send on a connected socket.
   /**
-   * This function is used to send data on the raw socket. The function call
-   * will block until the data has been sent successfully or an error occurs.
+   * This function is used to asynchronously send data on the raw socket. It is
+   * an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected raw
    * socket.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(this), handler, buffers, flags);
+        initiate_async_send(this), token, buffers, flags);
   }
 
   /// Send raw data to the specified endpoint.
@@ -599,28 +631,34 @@ public:
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send raw data to the specified
-   * remote endpoint. The function call always returns immediately.
+   * remote endpoint. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param destination The remote endpoint to which the data will be sent.
    * Copies will be made of the endpoint as required.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
@@ -632,65 +670,91 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send_to(this), handler, buffers,
+        initiate_async_send_to(this), token, buffers,
         destination, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send raw data to the specified
-   * remote endpoint. The function call always returns immediately.
+   * remote endpoint. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param destination The remote endpoint to which the data will be sent.
    * Copies will be made of the endpoint as required.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send_to(this), handler, buffers, destination, flags);
+        initiate_async_send_to(this), token, buffers, destination, flags);
   }
 
   /// Receive some data on a connected socket.
@@ -785,25 +849,31 @@ public:
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the raw
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
    * raw socket.
@@ -817,65 +887,91 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(this), handler,
+        initiate_async_receive(this), token,
         buffers, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the raw
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
    * raw socket.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(this), handler, buffers, flags);
+        initiate_async_receive(this), token, buffers, flags);
   }
 
   /// Receive raw data with the endpoint of the sender.
@@ -969,31 +1065,37 @@ public:
 
   /// Start an asynchronous receive.
   /**
-   * This function is used to asynchronously receive raw data. The function
-   * call always returns immediately.
+   * This function is used to asynchronously receive raw data. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the data. Ownership of the sender_endpoint object
    * is retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
+   * completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
@@ -1002,67 +1104,93 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive_from(this), handler, buffers,
+        initiate_async_receive_from(this), token, buffers,
         &sender_endpoint, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous receive.
   /**
-   * This function is used to asynchronously receive raw data. The function
-   * call always returns immediately.
+   * This function is used to asynchronously receive raw data. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the data. Ownership of the sender_endpoint object
    * is retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
+   * completion handler is called.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive_from(this), handler,
+        initiate_async_receive_from(this), token,
         buffers, &sender_endpoint, flags);
   }
 
diff --git a/boost/asio/basic_readable_pipe.hpp b/boost/asio/basic_readable_pipe.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e69a053d11cda9d936bfae5ba9e76f4699aece4a
--- /dev/null
+++ b/boost/asio/basic_readable_pipe.hpp
@@ -0,0 +1,531 @@
+//
+// basic_readable_pipe.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_READABLE_PIPE_HPP
+#define BOOST_ASIO_BASIC_READABLE_PIPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_PIPE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <string>
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/io_object_impl.hpp>
+#include <boost/asio/detail/non_const_lvalue.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/execution_context.hpp>
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/win_iocp_handle_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/io_uring_descriptor_service.hpp>
+#else
+# include <boost/asio/detail/reactive_descriptor_service.hpp>
+#endif
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Provides pipe functionality.
+/**
+ * The basic_readable_pipe class provides a wrapper over pipe
+ * functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <typename Executor = any_io_executor>
+class basic_readable_pipe
+{
+public:
+  /// The type of the executor associated with the object.
+  typedef Executor executor_type;
+
+  /// Rebinds the pipe type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The pipe type when rebound to the specified executor.
+    typedef basic_readable_pipe<Executor1> other;
+  };
+
+  /// The native representation of a pipe.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::win_iocp_handle_service::native_handle_type
+    native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  typedef detail::io_uring_descriptor_service::native_handle_type
+    native_handle_type;
+#else
+  typedef detail::reactive_descriptor_service::native_handle_type
+    native_handle_type;
+#endif
+
+  /// A basic_readable_pipe is always the lowest layer.
+  typedef basic_readable_pipe lowest_layer_type;
+
+  /// Construct a basic_readable_pipe without opening it.
+  /**
+   * This constructor creates a pipe without opening it.
+   *
+   * @param ex The I/O executor that the pipe will use, by default, to dispatch
+   * handlers for any asynchronous operations performed on the pipe.
+   */
+  explicit basic_readable_pipe(const executor_type& ex)
+    : impl_(0, ex)
+  {
+  }
+
+  /// Construct a basic_readable_pipe without opening it.
+  /**
+   * This constructor creates a pipe without opening it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the pipe will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the pipe.
+   */
+  template <typename ExecutionContext>
+  explicit basic_readable_pipe(ExecutionContext& context,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
+  {
+  }
+
+  /// Construct a basic_readable_pipe on an existing native pipe.
+  /**
+   * This constructor creates a pipe object to hold an existing native
+   * pipe.
+   *
+   * @param ex The I/O executor that the pipe will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the
+   * pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_readable_pipe(const executor_type& ex,
+      const native_handle_type& native_pipe)
+    : impl_(0, ex)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(impl_.get_implementation(),
+        native_pipe, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Construct a basic_readable_pipe on an existing native pipe.
+  /**
+   * This constructor creates a pipe object to hold an existing native
+   * pipe.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the pipe will use, by default, to dispatch handlers for any
+   * asynchronous operations performed on the pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_readable_pipe(ExecutionContext& context,
+      const native_handle_type& native_pipe,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value
+      >::type = 0)
+    : impl_(0, 0, context)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(impl_.get_implementation(),
+        native_pipe, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_readable_pipe from another.
+  /**
+   * This constructor moves a pipe from one object to another.
+   *
+   * @param other The other basic_readable_pipe object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_readable_pipe(const executor_type&)
+   * constructor.
+   */
+  basic_readable_pipe(basic_readable_pipe&& other)
+    : impl_(std::move(other.impl_))
+  {
+  }
+
+  /// Move-assign a basic_readable_pipe from another.
+  /**
+   * This assignment operator moves a pipe from one object to another.
+   *
+   * @param other The other basic_readable_pipe object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_readable_pipe(const executor_type&)
+   * constructor.
+   */
+  basic_readable_pipe& operator=(basic_readable_pipe&& other)
+  {
+    impl_ = std::move(other.impl_);
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destroys the pipe.
+  /**
+   * This function destroys the pipe, cancelling any outstanding
+   * asynchronous wait operations associated with the pipe as if by
+   * calling @c cancel.
+   */
+  ~basic_readable_pipe()
+  {
+  }
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() BOOST_ASIO_NOEXCEPT
+  {
+    return impl_.get_executor();
+  }
+
+  /// Get a reference to the lowest layer.
+  /**
+   * This function returns a reference to the lowest layer in a stack of
+   * layers. Since a basic_readable_pipe cannot contain any further layers, it
+   * simply returns a reference to itself.
+   *
+   * @return A reference to the lowest layer in the stack of layers. Ownership
+   * is not transferred to the caller.
+   */
+  lowest_layer_type& lowest_layer()
+  {
+    return *this;
+  }
+
+  /// Get a const reference to the lowest layer.
+  /**
+   * This function returns a const reference to the lowest layer in a stack of
+   * layers. Since a basic_readable_pipe cannot contain any further layers, it
+   * simply returns a reference to itself.
+   *
+   * @return A const reference to the lowest layer in the stack of layers.
+   * Ownership is not transferred to the caller.
+   */
+  const lowest_layer_type& lowest_layer() const
+  {
+    return *this;
+  }
+
+  /// Assign an existing native pipe to the pipe.
+  /*
+   * This function opens the pipe to hold an existing native pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void assign(const native_handle_type& native_pipe)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Assign an existing native pipe to the pipe.
+  /*
+   * This function opens the pipe to hold an existing native pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID assign(const native_handle_type& native_pipe,
+      boost::system::error_code& ec)
+  {
+    impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Determine whether the pipe is open.
+  bool is_open() const
+  {
+    return impl_.get_service().is_open(impl_.get_implementation());
+  }
+
+  /// Close the pipe.
+  /**
+   * This function is used to close the pipe. Any asynchronous read operations
+   * will be cancelled immediately, and will complete with the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void close()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().close(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "close");
+  }
+
+  /// Close the pipe.
+  /**
+   * This function is used to close the pipe. Any asynchronous read operations
+   * will be cancelled immediately, and will complete with the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID close(boost::system::error_code& ec)
+  {
+    impl_.get_service().close(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Get the native pipe representation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * pipe. This is intended to allow access to native pipe
+   * functionality that is not otherwise provided.
+   */
+  native_handle_type native_handle()
+  {
+    return impl_.get_service().native_handle(impl_.get_implementation());
+  }
+
+  /// Cancel all asynchronous operations associated with the pipe.
+  /**
+   * This function causes all outstanding asynchronous read operations to finish
+   * immediately, and the handlers for cancelled operations will be passed the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void cancel()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().cancel(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "cancel");
+  }
+
+  /// Cancel all asynchronous operations associated with the pipe.
+  /**
+   * This function causes all outstanding asynchronous read operations to finish
+   * immediately, and the handlers for cancelled operations will be passed the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID cancel(boost::system::error_code& ec)
+  {
+    impl_.get_service().cancel(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Read some data from the pipe.
+  /**
+   * This function is used to read data from the pipe. The function call will
+   * block until one or more bytes of data has been read successfully, or until
+   * an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @returns The number of bytes read.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read function if you need to ensure that
+   * the requested amount of data is read before the blocking operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * basic_readable_pipe.read_some(boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on reading into multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some(const MutableBufferSequence& buffers)
+  {
+    boost::system::error_code ec;
+    std::size_t s = impl_.get_service().read_some(
+        impl_.get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "read_some");
+    return s;
+  }
+
+  /// Read some data from the pipe.
+  /**
+   * This function is used to read data from the pipe. The function call will
+   * block until one or more bytes of data has been read successfully, or until
+   * an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read function if you need to ensure that
+   * the requested amount of data is read before the blocking operation
+   * completes.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some(const MutableBufferSequence& buffers,
+      boost::system::error_code& ec)
+  {
+    return impl_.get_service().read_some(
+        impl_.get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous read.
+  /**
+   * This function is used to asynchronously read data from the pipe. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the completion handler is called.
+   *
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes read.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @note The read operation may not read all of the requested number of bytes.
+   * Consider using the @ref async_read function if you need to ensure that the
+   * requested amount of data is read before the asynchronous operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * basic_readable_pipe.async_read_some(
+   *     boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on reading into multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
+      void (boost::system::error_code, std::size_t))
+  async_read_some(const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+  {
+    return async_initiate<ReadToken,
+      void (boost::system::error_code, std::size_t)>(
+        initiate_async_read_some(this), token, buffers);
+  }
+
+private:
+  // Disallow copying and assignment.
+  basic_readable_pipe(const basic_readable_pipe&) BOOST_ASIO_DELETED;
+  basic_readable_pipe& operator=(const basic_readable_pipe&) BOOST_ASIO_DELETED;
+
+  class initiate_async_read_some
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_read_some(basic_readable_pipe* self)
+      : self_(self)
+    {
+    }
+
+    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename ReadHandler, typename MutableBufferSequence>
+    void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+        const MutableBufferSequence& buffers) const
+    {
+      // If you get an error on the following line it means that your handler
+      // does not meet the documented type requirements for a ReadHandler.
+      BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+      detail::non_const_lvalue<ReadHandler> handler2(handler);
+      self_->impl_.get_service().async_read_some(
+          self_->impl_.get_implementation(), buffers,
+          handler2.value, self_->impl_.get_executor());
+    }
+
+  private:
+    basic_readable_pipe* self_;
+  };
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+  detail::io_object_impl<detail::win_iocp_handle_service, Executor> impl_;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  detail::io_object_impl<detail::io_uring_descriptor_service, Executor> impl_;
+#else
+  detail::io_object_impl<detail::reactive_descriptor_service, Executor> impl_;
+#endif
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_PIPE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_BASIC_READABLE_PIPE_HPP
diff --git a/boost/asio/basic_seq_packet_socket.hpp b/boost/asio/basic_seq_packet_socket.hpp
index ee506e05215f87cc219c2d2dc385f570ae231f3c..9d139be3a815ea4c791ebda3ef143ce9e0aa745c 100644
--- a/boost/asio/basic_seq_packet_socket.hpp
+++ b/boost/asio/basic_seq_packet_socket.hpp
@@ -2,7 +2,7 @@
 // basic_seq_packet_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -406,27 +406,33 @@ public:
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send data on the sequenced packet
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
@@ -435,21 +441,31 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(this), handler, buffers, flags);
+        initiate_async_send(this), token, buffers, flags);
   }
 
   /// Receive some data on the socket.
@@ -574,31 +590,37 @@ public:
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive data from the sequenced
-   * packet socket. The function call always returns immediately.
+   * packet socket. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param out_flags Once the asynchronous operation completes, contains flags
    * associated with the received data. For example, if the
    * socket_base::message_end_of_record bit is set then the received data marks
    * the end of a record. The caller must guarantee that the referenced
-   * variable remains valid until the handler is called.
+   * variable remains valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
@@ -608,33 +630,44 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags& out_flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive_with_flags(this), handler,
+        initiate_async_receive_with_flags(this), token,
         buffers, socket_base::message_flags(0), &out_flags);
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive data from the sequenced
-   * data socket. The function call always returns immediately.
+   * data socket. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param in_flags Flags specifying how the receive call is to be made.
    *
@@ -642,20 +675,25 @@ public:
    * associated with the received data. For example, if the
    * socket_base::message_end_of_record bit is set then the received data marks
    * the end of a record. The caller must guarantee that the referenced
-   * variable remains valid until the handler is called.
+   * variable remains valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
@@ -667,23 +705,33 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags in_flags,
       socket_base::message_flags& out_flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
         initiate_async_receive_with_flags(this),
-        handler, buffers, in_flags, &out_flags);
+        token, buffers, in_flags, &out_flags);
   }
 
 private:
diff --git a/boost/asio/basic_serial_port.hpp b/boost/asio/basic_serial_port.hpp
index 8db694d87e82cd961502507bd1328290822fd7ca..fd0d4bdf284a7fd75cdc9ee9fe849ee7b5b38447 100644
--- a/boost/asio/basic_serial_port.hpp
+++ b/boost/asio/basic_serial_port.hpp
@@ -2,7 +2,7 @@
 // basic_serial_port.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -35,7 +35,7 @@
 #if defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_serial_port_service.hpp>
 #else
-# include <boost/asio/detail/reactive_serial_port_service.hpp>
+# include <boost/asio/detail/posix_serial_port_service.hpp>
 #endif
 
 #if defined(BOOST_ASIO_HAS_MOVE)
@@ -79,7 +79,7 @@ public:
   typedef detail::win_iocp_serial_port_service::native_handle_type
     native_handle_type;
 #else
-  typedef detail::reactive_serial_port_service::native_handle_type
+  typedef detail::posix_serial_port_service::native_handle_type
     native_handle_type;
 #endif
 
@@ -657,25 +657,31 @@ public:
   /// Start an asynchronous write.
   /**
    * This function is used to asynchronously write data to the serial port.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be written to the serial port.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the write operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes written.
+   *   std::size_t bytes_transferred // Number of bytes written.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
@@ -689,20 +695,30 @@ public:
    * See the @ref buffer documentation for information on writing multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_write_some(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_write_some(this), handler, buffers);
+        initiate_async_write_some(this), token, buffers);
   }
 
   /// Read some data from the serial port.
@@ -771,25 +787,31 @@ public:
   /// Start an asynchronous read.
   /**
    * This function is used to asynchronously read data from the serial port.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more buffers into which the data will be read.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the read operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes read.
+   *   std::size_t bytes_transferred // Number of bytes read.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
    * requested amount of data is read before the asynchronous operation
@@ -804,20 +826,30 @@ public:
    * See the @ref buffer documentation for information on reading into multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_read_some(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_read_some(this), handler, buffers);
+        initiate_async_read_some(this), token, buffers);
   }
 
 private:
@@ -894,7 +926,7 @@ private:
 #if defined(BOOST_ASIO_HAS_IOCP)
   detail::io_object_impl<detail::win_iocp_serial_port_service, Executor> impl_;
 #else
-  detail::io_object_impl<detail::reactive_serial_port_service, Executor> impl_;
+  detail::io_object_impl<detail::posix_serial_port_service, Executor> impl_;
 #endif
 };
 
diff --git a/boost/asio/basic_signal_set.hpp b/boost/asio/basic_signal_set.hpp
index 20b6f0c0bd6298a6c2302caec9a212b393a8bdc2..1ac834839aa0c704e4ff214d930ecd812bcccbc0 100644
--- a/boost/asio/basic_signal_set.hpp
+++ b/boost/asio/basic_signal_set.hpp
@@ -2,7 +2,7 @@
 // basic_signal_set.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -495,39 +495,55 @@ public:
   /// Start an asynchronous operation to wait for a signal to be delivered.
   /**
    * This function may be used to initiate an asynchronous wait against the
-   * signal set. It always returns immediately.
+   * signal set. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
-   * For each call to async_wait(), the supplied handler will be called exactly
-   * once. The handler will be called when:
+   * For each call to async_wait(), the completion handler will be called
+   * exactly once. The completion handler will be called when:
    *
    * @li One of the registered signals in the signal set occurs; or
    *
    * @li The signal set was cancelled, in which case the handler is passed the
    * error code boost::asio::error::operation_aborted.
    *
-   * @param handler The handler to be called when the signal occurs. Copies
-   * will be made of the handler as required. The function signature of the
-   * handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the wait completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   int signal_number // Indicates which signal occurred.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, int) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code, int))
-      SignalHandler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(SignalHandler,
+      SignalToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(SignalToken,
       void (boost::system::error_code, int))
   async_wait(
-      BOOST_ASIO_MOVE_ARG(SignalHandler) handler
+      BOOST_ASIO_MOVE_ARG(SignalToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<SignalHandler, void (boost::system::error_code, int)>(
-        initiate_async_wait(this), handler);
+    return async_initiate<SignalToken, void (boost::system::error_code, int)>(
+        initiate_async_wait(this), token);
   }
 
 private:
diff --git a/boost/asio/basic_socket.hpp b/boost/asio/basic_socket.hpp
index dedbe15445d824354eb7784d1df7e28d2111a046..a718ca186115cb37faf59f73f25428c7f607eabb 100644
--- a/boost/asio/basic_socket.hpp
+++ b/boost/asio/basic_socket.hpp
@@ -2,7 +2,7 @@
 // basic_socket.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -32,6 +32,8 @@
 # include <boost/asio/detail/null_socket_service.hpp>
 #elif defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_socket_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/io_uring_socket_service.hpp>
 #else
 # include <boost/asio/detail/reactive_socket_service.hpp>
 #endif
@@ -88,6 +90,9 @@ public:
 #elif defined(BOOST_ASIO_HAS_IOCP)
   typedef typename detail::win_iocp_socket_service<
     Protocol>::native_handle_type native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  typedef typename detail::io_uring_socket_service<
+    Protocol>::native_handle_type native_handle_type;
 #else
   typedef typename detail::reactive_socket_service<
     Protocol>::native_handle_type native_handle_type;
@@ -903,7 +908,8 @@ public:
   /// Start an asynchronous connect.
   /**
    * This function is used to asynchronously connect a socket to the specified
-   * remote endpoint. The function call always returns immediately.
+   * remote endpoint. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * The socket is automatically opened if it is not already open. If the
    * connect fails, and the socket was automatically opened, the socket is
@@ -912,17 +918,22 @@ public:
    * @param peer_endpoint The remote endpoint to which the socket will be
    * connected. Copies will be made of the endpoint object as required.
    *
-   * @param handler The handler to be called when the connection operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the connect completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
-   *   const boost::system::error_code& error // Result of operation
+   *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
    * @par Example
    * @code
    * void connect_handler(const boost::system::error_code& error)
@@ -940,14 +951,24 @@ public:
    *     boost::asio::ip::address::from_string("1.2.3.4"), 12345);
    * socket.async_connect(endpoint, connect_handler);
    * @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
-        ConnectHandler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ConnectHandler,
+        ConnectToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ConnectToken,
       void (boost::system::error_code))
   async_connect(const endpoint_type& peer_endpoint,
-      BOOST_ASIO_MOVE_ARG(ConnectHandler) handler
+      BOOST_ASIO_MOVE_ARG(ConnectToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
     boost::system::error_code open_ec;
@@ -957,8 +978,8 @@ public:
       impl_.get_service().open(impl_.get_implementation(), protocol, open_ec);
     }
 
-    return async_initiate<ConnectHandler, void (boost::system::error_code)>(
-        initiate_async_connect(this), handler, peer_endpoint, open_ec);
+    return async_initiate<ConnectToken, void (boost::system::error_code)>(
+        initiate_async_connect(this), token, peer_endpoint, open_ec);
   }
 
   /// Set an option on the socket.
@@ -1742,21 +1763,28 @@ public:
   /// write, or to have pending error conditions.
   /**
    * This function is used to perform an asynchronous wait for a socket to enter
-   * a ready to read, write or error condition state.
+   * a ready to read, write or error condition state. It is an initiating
+   * function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param w Specifies the desired socket state.
    *
-   * @param handler The handler to be called when the wait operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the wait completes. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
-   *   const boost::system::error_code& error // Result of operation
+   *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
    * @par Example
    * @code
    * void wait_handler(const boost::system::error_code& error)
@@ -1773,18 +1801,28 @@ public:
    * ...
    * socket.async_wait(boost::asio::ip::tcp::socket::wait_read, wait_handler);
    * @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
-        WaitHandler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitHandler,
+        WaitToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitToken,
       void (boost::system::error_code))
   async_wait(wait_type w,
-      BOOST_ASIO_MOVE_ARG(WaitHandler) handler
+      BOOST_ASIO_MOVE_ARG(WaitToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WaitHandler, void (boost::system::error_code)>(
-        initiate_async_wait(this), handler, w);
+    return async_initiate<WaitToken, void (boost::system::error_code)>(
+        initiate_async_wait(this), token, w);
   }
 
 protected:
@@ -1803,6 +1841,9 @@ protected:
 #elif defined(BOOST_ASIO_HAS_IOCP)
   detail::io_object_impl<
     detail::win_iocp_socket_service<Protocol>, Executor> impl_;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  detail::io_object_impl<
+    detail::io_uring_socket_service<Protocol>, Executor> impl_;
 #else
   detail::io_object_impl<
     detail::reactive_socket_service<Protocol>, Executor> impl_;
diff --git a/boost/asio/basic_socket_acceptor.hpp b/boost/asio/basic_socket_acceptor.hpp
index 918b9fe70da4d877a24dc4dea730bc6575118cbc..fe048266f57035b96ccb991649230d7de38d34bb 100644
--- a/boost/asio/basic_socket_acceptor.hpp
+++ b/boost/asio/basic_socket_acceptor.hpp
@@ -2,7 +2,7 @@
 // basic_socket_acceptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -31,6 +31,8 @@
 # include <boost/asio/detail/null_socket_service.hpp>
 #elif defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_socket_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/io_uring_socket_service.hpp>
 #else
 # include <boost/asio/detail/reactive_socket_service.hpp>
 #endif
@@ -104,6 +106,9 @@ public:
 #elif defined(BOOST_ASIO_HAS_IOCP)
   typedef typename detail::win_iocp_socket_service<
     Protocol>::native_handle_type native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  typedef typename detail::io_uring_socket_service<
+    Protocol>::native_handle_type native_handle_type;
 #else
   typedef typename detail::reactive_socket_service<
     Protocol>::native_handle_type native_handle_type;
@@ -1192,21 +1197,28 @@ public:
   /// write, or to have pending error conditions.
   /**
    * This function is used to perform an asynchronous wait for an acceptor to
-   * enter a ready to read, write or error condition state.
+   * enter a ready to read, write or error condition state. It is an initiating
+   * function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param w Specifies the desired acceptor state.
    *
-   * @param handler The handler to be called when the wait operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the wait completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
-   *   const boost::system::error_code& error // Result of operation
+   *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
    * @par Example
    * @code
    * void wait_handler(const boost::system::error_code& error)
@@ -1225,18 +1237,28 @@ public:
    *     boost::asio::ip::tcp::acceptor::wait_read,
    *     wait_handler);
    * @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
-        WaitHandler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitHandler,
+        WaitToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitToken,
       void (boost::system::error_code))
   async_wait(wait_type w,
-      BOOST_ASIO_MOVE_ARG(WaitHandler) handler
+      BOOST_ASIO_MOVE_ARG(WaitToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WaitHandler, void (boost::system::error_code)>(
-        initiate_async_wait(this), handler, w);
+    return async_initiate<WaitToken, void (boost::system::error_code)>(
+        initiate_async_wait(this), token, w);
   }
 
 #if !defined(BOOST_ASIO_NO_EXTENSIONS)
@@ -1308,23 +1330,30 @@ public:
   /// Start an asynchronous accept.
   /**
    * This function is used to asynchronously accept a new connection into a
-   * socket. The function call always returns immediately.
+   * socket, and additionally obtain the endpoint of the remote peer. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param peer The socket into which the new connection will be accepted.
    * Ownership of the peer object is retained by the caller, which must
-   * guarantee that it is valid until the handler is called.
+   * guarantee that it is valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the accept operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the accept completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
    * @par Example
    * @code
    * void accept_handler(const boost::system::error_code& error)
@@ -1342,21 +1371,31 @@ public:
    * boost::asio::ip::tcp::socket socket(my_context);
    * acceptor.async_accept(socket, accept_handler);
    * @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename Protocol1, typename Executor1,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
-        AcceptHandler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(AcceptHandler,
+        AcceptToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(AcceptToken,
       void (boost::system::error_code))
   async_accept(basic_socket<Protocol1, Executor1>& peer,
-      BOOST_ASIO_MOVE_ARG(AcceptHandler) handler
+      BOOST_ASIO_MOVE_ARG(AcceptToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type),
       typename constraint<
         is_convertible<Protocol, Protocol1>::value
       >::type = 0)
   {
-    return async_initiate<AcceptHandler, void (boost::system::error_code)>(
-        initiate_async_accept(this), handler,
+    return async_initiate<AcceptToken, void (boost::system::error_code)>(
+        initiate_async_accept(this), token,
         &peer, static_cast<endpoint_type*>(0));
   }
 
@@ -1433,41 +1472,57 @@ public:
   /// Start an asynchronous accept.
   /**
    * This function is used to asynchronously accept a new connection into a
-   * socket, and additionally obtain the endpoint of the remote peer. The
-   * function call always returns immediately.
+   * socket, and additionally obtain the endpoint of the remote peer. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param peer The socket into which the new connection will be accepted.
    * Ownership of the peer object is retained by the caller, which must
-   * guarantee that it is valid until the handler is called.
+   * guarantee that it is valid until the completion handler is called.
    *
    * @param peer_endpoint An endpoint object into which the endpoint of the
    * remote peer will be written. Ownership of the peer_endpoint object is
    * retained by the caller, which must guarantee that it is valid until the
    * handler is called.
    *
-   * @param handler The handler to be called when the accept operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the accept completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename Executor1,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
-        AcceptHandler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(AcceptHandler,
+        AcceptToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(AcceptToken,
       void (boost::system::error_code))
   async_accept(basic_socket<protocol_type, Executor1>& peer,
       endpoint_type& peer_endpoint,
-      BOOST_ASIO_MOVE_ARG(AcceptHandler) handler
+      BOOST_ASIO_MOVE_ARG(AcceptToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<AcceptHandler, void (boost::system::error_code)>(
-        initiate_async_accept(this), handler, &peer, &peer_endpoint);
+    return async_initiate<AcceptToken, void (boost::system::error_code)>(
+        initiate_async_accept(this), token, &peer, &peer_endpoint);
   }
 #endif // !defined(BOOST_ASIO_NO_EXTENSIONS)
 
@@ -1539,27 +1594,36 @@ public:
 
   /// Start an asynchronous accept.
   /**
-   * This function is used to asynchronously accept a new connection. The
-   * function call always returns immediately.
+   * This function is used to asynchronously accept a new connection. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * This overload requires that the Protocol template parameter satisfy the
    * AcceptableProtocol type requirements.
    *
-   * @param handler The handler to be called when the accept operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the accept completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   // Result of operation.
    *   const boost::system::error_code& error,
+   *
    *   // On success, the newly accepted socket.
    *   typename Protocol::socket::template
    *     rebind_executor<executor_type>::other peer
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code,
+   *    typename Protocol::socket::template
+   *      rebind_executor<executor_type>::other)) @endcode
+   *
    * @par Example
    * @code
    * void accept_handler(const boost::system::error_code& error,
@@ -1577,24 +1641,34 @@ public:
    * ...
    * acceptor.async_accept(accept_handler);
    * @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         typename Protocol::socket::template rebind_executor<
-          executor_type>::other)) MoveAcceptHandler
+          executor_type>::other)) MoveAcceptToken
             BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(MoveAcceptHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(MoveAcceptToken,
       void (boost::system::error_code,
         typename Protocol::socket::template
           rebind_executor<executor_type>::other))
   async_accept(
-      BOOST_ASIO_MOVE_ARG(MoveAcceptHandler) handler
+      BOOST_ASIO_MOVE_ARG(MoveAcceptToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<MoveAcceptHandler,
+    return async_initiate<MoveAcceptToken,
       void (boost::system::error_code, typename Protocol::socket::template
         rebind_executor<executor_type>::other)>(
-          initiate_async_move_accept(this), handler,
+          initiate_async_move_accept(this), token,
           impl_.get_executor(), static_cast<endpoint_type*>(0),
           static_cast<typename Protocol::socket::template
             rebind_executor<executor_type>::other*>(0));
@@ -1764,8 +1838,9 @@ public:
 
   /// Start an asynchronous accept.
   /**
-   * This function is used to asynchronously accept a new connection. The
-   * function call always returns immediately.
+   * This function is used to asynchronously accept a new connection. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * This overload requires that the Protocol template parameter satisfy the
    * AcceptableProtocol type requirements.
@@ -1773,19 +1848,29 @@ public:
    * @param ex The I/O executor object to be used for the newly accepted
    * socket.
    *
-   * @param handler The handler to be called when the accept operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the accept completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
-   *   const boost::system::error_code& error, // Result of operation.
+   *   // Result of operation.
+   *   const boost::system::error_code& error,
+   *
+   *   // On success, the newly accepted socket.
    *   typename Protocol::socket::template rebind_executor<
-   *     Executor1>::other peer // On success, the newly accepted socket.
+   *     Executor1>::other peer
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code,
+   *    typename Protocol::socket::template rebind_executor<
+   *      Executor1>::other)) @endcode
+   *
    * @par Example
    * @code
    * void accept_handler(const boost::system::error_code& error,
@@ -1803,18 +1888,28 @@ public:
    * ...
    * acceptor.async_accept(my_context2, accept_handler);
    * @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename Executor1,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         typename Protocol::socket::template rebind_executor<
-          Executor1>::other)) MoveAcceptHandler
+          Executor1>::other)) MoveAcceptToken
             BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(MoveAcceptHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(MoveAcceptToken,
       void (boost::system::error_code,
         typename Protocol::socket::template rebind_executor<
           Executor1>::other))
   async_accept(const Executor1& ex,
-      BOOST_ASIO_MOVE_ARG(MoveAcceptHandler) handler
+      BOOST_ASIO_MOVE_ARG(MoveAcceptToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type),
       typename constraint<
         is_executor<Executor1>::value
@@ -1824,17 +1919,18 @@ public:
     typedef typename Protocol::socket::template rebind_executor<
       Executor1>::other other_socket_type;
 
-    return async_initiate<MoveAcceptHandler,
+    return async_initiate<MoveAcceptToken,
       void (boost::system::error_code, other_socket_type)>(
-        initiate_async_move_accept(this), handler,
+        initiate_async_move_accept(this), token,
         ex, static_cast<endpoint_type*>(0),
         static_cast<other_socket_type*>(0));
   }
 
   /// Start an asynchronous accept.
   /**
-   * This function is used to asynchronously accept a new connection. The
-   * function call always returns immediately.
+   * This function is used to asynchronously accept a new connection. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * This overload requires that the Protocol template parameter satisfy the
    * AcceptableProtocol type requirements.
@@ -1842,20 +1938,29 @@ public:
    * @param context The I/O execution context object to be used for the newly
    * accepted socket.
    *
-   * @param handler The handler to be called when the accept operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the accept completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
-   *   const boost::system::error_code& error, // Result of operation.
+   *   // Result of operation.
+   *   const boost::system::error_code& error,
+   *
+   *   // On success, the newly accepted socket.
    *   typename Protocol::socket::template rebind_executor<
    *     typename ExecutionContext::executor_type>::other peer
-   *       // On success, the newly accepted socket.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code,
+   *    typename Protocol::socket::template rebind_executor<
+   *      typename ExecutionContext::executor_type>::other)) @endcode
+   *
    * @par Example
    * @code
    * void accept_handler(const boost::system::error_code& error,
@@ -1873,18 +1978,28 @@ public:
    * ...
    * acceptor.async_accept(my_context2, accept_handler);
    * @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ExecutionContext,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         typename Protocol::socket::template rebind_executor<
-          typename ExecutionContext::executor_type>::other)) MoveAcceptHandler
+          typename ExecutionContext::executor_type>::other)) MoveAcceptToken
             BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(MoveAcceptHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(MoveAcceptToken,
       void (boost::system::error_code,
         typename Protocol::socket::template rebind_executor<
           typename ExecutionContext::executor_type>::other))
   async_accept(ExecutionContext& context,
-      BOOST_ASIO_MOVE_ARG(MoveAcceptHandler) handler
+      BOOST_ASIO_MOVE_ARG(MoveAcceptToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type),
       typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
@@ -1893,9 +2008,9 @@ public:
     typedef typename Protocol::socket::template rebind_executor<
       typename ExecutionContext::executor_type>::other other_socket_type;
 
-    return async_initiate<MoveAcceptHandler,
+    return async_initiate<MoveAcceptToken,
       void (boost::system::error_code, other_socket_type)>(
-        initiate_async_move_accept(this), handler,
+        initiate_async_move_accept(this), token,
         context.get_executor(), static_cast<endpoint_type*>(0),
         static_cast<other_socket_type*>(0));
   }
@@ -1977,8 +2092,9 @@ public:
 
   /// Start an asynchronous accept.
   /**
-   * This function is used to asynchronously accept a new connection. The
-   * function call always returns immediately.
+   * This function is used to asynchronously accept a new connection. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * This overload requires that the Protocol template parameter satisfy the
    * AcceptableProtocol type requirements.
@@ -1986,23 +2102,31 @@ public:
    * @param peer_endpoint An endpoint object into which the endpoint of the
    * remote peer will be written. Ownership of the peer_endpoint object is
    * retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
+   * completion handler is called.
    *
-   * @param handler The handler to be called when the accept operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the accept completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   // Result of operation.
    *   const boost::system::error_code& error,
+   *
    *   // On success, the newly accepted socket.
    *   typename Protocol::socket::template
    *     rebind_executor<executor_type>::other peer
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code,
+   *    typename Protocol::socket::template
+   *      rebind_executor<executor_type>::other)) @endcode
+   *
    * @par Example
    * @code
    * void accept_handler(const boost::system::error_code& error,
@@ -2021,24 +2145,34 @@ public:
    * boost::asio::ip::tcp::endpoint endpoint;
    * acceptor.async_accept(endpoint, accept_handler);
    * @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         typename Protocol::socket::template rebind_executor<
-          executor_type>::other)) MoveAcceptHandler
+          executor_type>::other)) MoveAcceptToken
             BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(MoveAcceptHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(MoveAcceptToken,
       void (boost::system::error_code,
         typename Protocol::socket::template
           rebind_executor<executor_type>::other))
   async_accept(endpoint_type& peer_endpoint,
-      BOOST_ASIO_MOVE_ARG(MoveAcceptHandler) handler
+      BOOST_ASIO_MOVE_ARG(MoveAcceptToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<MoveAcceptHandler,
+    return async_initiate<MoveAcceptToken,
       void (boost::system::error_code, typename Protocol::socket::template
         rebind_executor<executor_type>::other)>(
-          initiate_async_move_accept(this), handler,
+          initiate_async_move_accept(this), token,
           impl_.get_executor(), &peer_endpoint,
           static_cast<typename Protocol::socket::template
             rebind_executor<executor_type>::other*>(0));
@@ -2234,8 +2368,9 @@ public:
 
   /// Start an asynchronous accept.
   /**
-   * This function is used to asynchronously accept a new connection. The
-   * function call always returns immediately.
+   * This function is used to asynchronously accept a new connection. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * This overload requires that the Protocol template parameter satisfy the
    * AcceptableProtocol type requirements.
@@ -2246,21 +2381,31 @@ public:
    * @param peer_endpoint An endpoint object into which the endpoint of the
    * remote peer will be written. Ownership of the peer_endpoint object is
    * retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
+   * completion handler is called.
    *
-   * @param handler The handler to be called when the accept operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the accept completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
-   *   const boost::system::error_code& error, // Result of operation.
+   *   // Result of operation.
+   *   const boost::system::error_code& error,
+   *
+   *   // On success, the newly accepted socket.
    *   typename Protocol::socket::template rebind_executor<
-   *     Executor1>::other peer // On success, the newly accepted socket.
+   *     Executor1>::other peer
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code,
+   *    typename Protocol::socket::template rebind_executor<
+   *      Executor1>::other)) @endcode
+   *
    * @par Example
    * @code
    * void accept_handler(const boost::system::error_code& error,
@@ -2279,18 +2424,28 @@ public:
    * boost::asio::ip::tcp::endpoint endpoint;
    * acceptor.async_accept(my_context2, endpoint, accept_handler);
    * @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename Executor1,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         typename Protocol::socket::template rebind_executor<
-          Executor1>::other)) MoveAcceptHandler
+          Executor1>::other)) MoveAcceptToken
             BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(MoveAcceptHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(MoveAcceptToken,
       void (boost::system::error_code,
         typename Protocol::socket::template rebind_executor<
           Executor1>::other))
   async_accept(const Executor1& ex, endpoint_type& peer_endpoint,
-      BOOST_ASIO_MOVE_ARG(MoveAcceptHandler) handler
+      BOOST_ASIO_MOVE_ARG(MoveAcceptToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type),
       typename constraint<
         is_executor<Executor1>::value
@@ -2300,17 +2455,18 @@ public:
     typedef typename Protocol::socket::template rebind_executor<
       Executor1>::other other_socket_type;
 
-    return async_initiate<MoveAcceptHandler,
+    return async_initiate<MoveAcceptToken,
       void (boost::system::error_code, other_socket_type)>(
-        initiate_async_move_accept(this), handler,
+        initiate_async_move_accept(this), token,
         ex, &peer_endpoint,
         static_cast<other_socket_type*>(0));
   }
 
   /// Start an asynchronous accept.
   /**
-   * This function is used to asynchronously accept a new connection. The
-   * function call always returns immediately.
+   * This function is used to asynchronously accept a new connection. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * This overload requires that the Protocol template parameter satisfy the
    * AcceptableProtocol type requirements.
@@ -2321,22 +2477,31 @@ public:
    * @param peer_endpoint An endpoint object into which the endpoint of the
    * remote peer will be written. Ownership of the peer_endpoint object is
    * retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
+   * completion handler is called.
    *
-   * @param handler The handler to be called when the accept operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the accept completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
-   *   const boost::system::error_code& error, // Result of operation.
+   *   // Result of operation.
+   *   const boost::system::error_code& error,
+   *
+   *   // On success, the newly accepted socket.
    *   typename Protocol::socket::template rebind_executor<
    *     typename ExecutionContext::executor_type>::other peer
-   *       // On success, the newly accepted socket.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code,
+   *    typename Protocol::socket::template rebind_executor<
+   *      typename ExecutionContext::executor_type>::other)) @endcode
+   *
    * @par Example
    * @code
    * void accept_handler(const boost::system::error_code& error,
@@ -2355,19 +2520,29 @@ public:
    * boost::asio::ip::tcp::endpoint endpoint;
    * acceptor.async_accept(my_context2, endpoint, accept_handler);
    * @endcode
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ExecutionContext,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         typename Protocol::socket::template rebind_executor<
-          typename ExecutionContext::executor_type>::other)) MoveAcceptHandler
+          typename ExecutionContext::executor_type>::other)) MoveAcceptToken
             BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(MoveAcceptHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(MoveAcceptToken,
       void (boost::system::error_code,
         typename Protocol::socket::template rebind_executor<
           typename ExecutionContext::executor_type>::other))
   async_accept(ExecutionContext& context,
       endpoint_type& peer_endpoint,
-      BOOST_ASIO_MOVE_ARG(MoveAcceptHandler) handler
+      BOOST_ASIO_MOVE_ARG(MoveAcceptToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type),
       typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
@@ -2376,9 +2551,9 @@ public:
     typedef typename Protocol::socket::template rebind_executor<
       typename ExecutionContext::executor_type>::other other_socket_type;
 
-    return async_initiate<MoveAcceptHandler,
+    return async_initiate<MoveAcceptToken,
       void (boost::system::error_code, other_socket_type)>(
-        initiate_async_move_accept(this), handler,
+        initiate_async_move_accept(this), token,
         context.get_executor(), &peer_endpoint,
         static_cast<other_socket_type*>(0));
   }
@@ -2496,6 +2671,9 @@ private:
 #elif defined(BOOST_ASIO_HAS_IOCP)
   detail::io_object_impl<
     detail::win_iocp_socket_service<Protocol>, Executor> impl_;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  detail::io_object_impl<
+    detail::io_uring_socket_service<Protocol>, Executor> impl_;
 #else
   detail::io_object_impl<
     detail::reactive_socket_service<Protocol>, Executor> impl_;
diff --git a/boost/asio/basic_socket_iostream.hpp b/boost/asio/basic_socket_iostream.hpp
index 51d1103d7fca01147dda1beb6e218a2c758ec9f7..3223ac77a19f262b41fc30b6ec65a654cb0997fd 100644
--- a/boost/asio/basic_socket_iostream.hpp
+++ b/boost/asio/basic_socket_iostream.hpp
@@ -2,7 +2,7 @@
 // basic_socket_iostream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/basic_socket_streambuf.hpp b/boost/asio/basic_socket_streambuf.hpp
index bd9c8d8d5a0a2938ea9c20aad2ae0715e4003abe..3173c01bcabbca1892ab077e44b5e5a1ba50477d 100644
--- a/boost/asio/basic_socket_streambuf.hpp
+++ b/boost/asio/basic_socket_streambuf.hpp
@@ -2,7 +2,7 @@
 // basic_socket_streambuf.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/basic_stream_file.hpp b/boost/asio/basic_stream_file.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..188981c29eb285da062a344f6efe99d9d51a5ca0
--- /dev/null
+++ b/boost/asio/basic_stream_file.hpp
@@ -0,0 +1,744 @@
+//
+// basic_stream_file.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_STREAM_FILE_HPP
+#define BOOST_ASIO_BASIC_STREAM_FILE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_FILE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <cstddef>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/basic_file.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/non_const_lvalue.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+#if !defined(BOOST_ASIO_BASIC_STREAM_FILE_FWD_DECL)
+#define BOOST_ASIO_BASIC_STREAM_FILE_FWD_DECL
+
+// Forward declaration with defaulted arguments.
+template <typename Executor = any_io_executor>
+class basic_stream_file;
+
+#endif // !defined(BOOST_ASIO_BASIC_STREAM_FILE_FWD_DECL)
+
+/// Provides stream-oriented file functionality.
+/**
+ * The basic_stream_file class template provides asynchronous and blocking
+ * stream-oriented file functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
+ */
+template <typename Executor>
+class basic_stream_file
+  : public basic_file<Executor>
+{
+public:
+  /// The type of the executor associated with the object.
+  typedef Executor executor_type;
+
+  /// Rebinds the file type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The file type when rebound to the specified executor.
+    typedef basic_stream_file<Executor1> other;
+  };
+
+  /// The native representation of a file.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#else
+  typedef typename basic_file<Executor>::native_handle_type native_handle_type;
+#endif
+
+  /// Construct a basic_stream_file without opening it.
+  /**
+   * This constructor initialises a file without opening it. The file needs to
+   * be opened before data can be read from or or written to it.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   */
+  explicit basic_stream_file(const executor_type& ex)
+    : basic_file<Executor>(ex)
+  {
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+  }
+
+  /// Construct a basic_stream_file without opening it.
+  /**
+   * This constructor initialises a file without opening it. The file needs to
+   * be opened before data can be read from or or written to it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   */
+  template <typename ExecutionContext>
+  explicit basic_stream_file(ExecutionContext& context,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context)
+  {
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+  }
+
+  /// Construct and open a basic_stream_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_stream_file(const executor_type& ex,
+      const char* path, file_base::flags open_flags)
+    : basic_file<Executor>(ex)
+  {
+    boost::system::error_code ec;
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+    this->impl_.get_service().open(
+        this->impl_.get_implementation(),
+        path, open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct and open a basic_stream_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_stream_file(ExecutionContext& context,
+      const char* path, file_base::flags open_flags,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context)
+  {
+    boost::system::error_code ec;
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+    this->impl_.get_service().open(
+        this->impl_.get_implementation(),
+        path, open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct and open a basic_stream_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_stream_file(const executor_type& ex,
+      const std::string& path, file_base::flags open_flags)
+    : basic_file<Executor>(ex)
+  {
+    boost::system::error_code ec;
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+    this->impl_.get_service().open(
+        this->impl_.get_implementation(),
+        path.c_str(), open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct and open a basic_stream_file.
+  /**
+   * This constructor initialises and opens a file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param path The path name identifying the file to be opened.
+   *
+   * @param open_flags A set of flags that determine how the file should be
+   * opened.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_stream_file(ExecutionContext& context,
+      const std::string& path, file_base::flags open_flags,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context)
+  {
+    boost::system::error_code ec;
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+    this->impl_.get_service().open(
+        this->impl_.get_implementation(),
+        path.c_str(), open_flags, ec);
+    boost::asio::detail::throw_error(ec, "open");
+  }
+
+  /// Construct a basic_stream_file on an existing native file.
+  /**
+   * This constructor initialises a stream file object to hold an existing
+   * native file.
+   *
+   * @param ex The I/O executor that the file will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the file.
+   *
+   * @param native_file The new underlying file implementation.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_stream_file(const executor_type& ex,
+      const native_handle_type& native_file)
+    : basic_file<Executor>(ex, native_file)
+  {
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+  }
+
+  /// Construct a basic_stream_file on an existing native file.
+  /**
+   * This constructor initialises a stream file object to hold an existing
+   * native file.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the file will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the file.
+   *
+   * @param native_file The new underlying file implementation.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_stream_file(ExecutionContext& context,
+      const native_handle_type& native_file,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(context, native_file)
+  {
+    this->impl_.get_service().set_is_stream(
+        this->impl_.get_implementation(), true);
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_stream_file from another.
+  /**
+   * This constructor moves a stream file from one object to another.
+   *
+   * @param other The other basic_stream_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_file(const executor_type&)
+   * constructor.
+   */
+  basic_stream_file(basic_stream_file&& other) BOOST_ASIO_NOEXCEPT
+    : basic_file<Executor>(std::move(other))
+  {
+  }
+
+  /// Move-assign a basic_stream_file from another.
+  /**
+   * This assignment operator moves a stream file from one object to another.
+   *
+   * @param other The other basic_stream_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_file(const executor_type&)
+   * constructor.
+   */
+  basic_stream_file& operator=(basic_stream_file&& other)
+  {
+    basic_file<Executor>::operator=(std::move(other));
+    return *this;
+  }
+
+  /// Move-construct a basic_stream_file from a file of another executor
+  /// type.
+  /**
+   * This constructor moves a stream file from one object to another.
+   *
+   * @param other The other basic_stream_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_file(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  basic_stream_file(basic_stream_file<Executor1>&& other,
+      typename constraint<
+        is_convertible<Executor1, Executor>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : basic_file<Executor>(std::move(other))
+  {
+  }
+
+  /// Move-assign a basic_stream_file from a file of another executor type.
+  /**
+   * This assignment operator moves a stream file from one object to another.
+   *
+   * @param other The other basic_stream_file object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_file(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  typename constraint<
+    is_convertible<Executor1, Executor>::value,
+    basic_stream_file&
+  >::type operator=(basic_stream_file<Executor1>&& other)
+  {
+    basic_file<Executor>::operator=(std::move(other));
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destroys the file.
+  /**
+   * This function destroys the file, cancelling any outstanding asynchronous
+   * operations associated with the file as if by calling @c cancel.
+   */
+  ~basic_stream_file()
+  {
+  }
+
+  /// Seek to a position in the file.
+  /**
+   * This function updates the current position in the file.
+   *
+   * @param offset The requested position in the file, relative to @c whence.
+   *
+   * @param whence One of @c seek_set, @c seek_cur or @c seek_end.
+   *
+   * @returns The new position relative to the beginning of the file.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  uint64_t seek(int64_t offset, file_base::seek_basis whence)
+  {
+    boost::system::error_code ec;
+    uint64_t n = this->impl_.get_service().seek(
+        this->impl_.get_implementation(), offset, whence, ec);
+    boost::asio::detail::throw_error(ec, "seek");
+    return n;
+  }
+
+  /// Seek to a position in the file.
+  /**
+   * This function updates the current position in the file.
+   *
+   * @param offset The requested position in the file, relative to @c whence.
+   *
+   * @param whence One of @c seek_set, @c seek_cur or @c seek_end.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The new position relative to the beginning of the file.
+   */
+  uint64_t seek(int64_t offset, file_base::seek_basis whence,
+      boost::system::error_code& ec)
+  {
+    return this->impl_.get_service().seek(
+        this->impl_.get_implementation(), offset, whence, ec);
+  }
+
+  /// Write some data to the file.
+  /**
+   * This function is used to write data to the stream file. The function call
+   * will block until one or more bytes of the data has been written
+   * successfully, or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the file.
+   *
+   * @returns The number of bytes written.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the end of the file was reached.
+   *
+   * @note The write_some operation may not transmit all of the data to the
+   * peer. Consider using the @ref write function if you need to ensure that
+   * all data is written before the blocking operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * file.write_some(boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on writing multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some(const ConstBufferSequence& buffers)
+  {
+    boost::system::error_code ec;
+    std::size_t s = this->impl_.get_service().write_some(
+        this->impl_.get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "write_some");
+    return s;
+  }
+
+  /// Write some data to the file.
+  /**
+   * This function is used to write data to the stream file. The function call
+   * will block until one or more bytes of the data has been written
+   * successfully, or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the file.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes written. Returns 0 if an error occurred.
+   *
+   * @note The write_some operation may not transmit all of the data to the
+   * peer. Consider using the @ref write function if you need to ensure that
+   * all data is written before the blocking operation completes.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some(const ConstBufferSequence& buffers,
+      boost::system::error_code& ec)
+  {
+    return this->impl_.get_service().write_some(
+        this->impl_.get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous write.
+  /**
+   * This function is used to asynchronously write data to the stream file.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
+   *
+   * @param buffers One or more data buffers to be written to the file.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the completion handler is called.
+   *
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes written.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @note The write operation may not transmit all of the data to the peer.
+   * Consider using the @ref async_write function if you need to ensure that all
+   * data is written before the asynchronous operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * file.async_write_some(boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on writing multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
+   */
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
+      void (boost::system::error_code, std::size_t))
+  async_write_some(const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+  {
+    return async_initiate<WriteToken,
+      void (boost::system::error_code, std::size_t)>(
+        initiate_async_write_some(this), token, buffers);
+  }
+
+  /// Read some data from the file.
+  /**
+   * This function is used to read data from the stream file. The function
+   * call will block until one or more bytes of data has been read successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @returns The number of bytes read.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the end of the file was reached.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read function if you need to ensure that
+   * the requested amount of data is read before the blocking operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * file.read_some(boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on reading into multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some(const MutableBufferSequence& buffers)
+  {
+    boost::system::error_code ec;
+    std::size_t s = this->impl_.get_service().read_some(
+        this->impl_.get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "read_some");
+    return s;
+  }
+
+  /// Read some data from the file.
+  /**
+   * This function is used to read data from the stream file. The function
+   * call will block until one or more bytes of data has been read successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred.
+   *
+   * @note The read_some operation may not read all of the requested number of
+   * bytes. Consider using the @ref read function if you need to ensure that
+   * the requested amount of data is read before the blocking operation
+   * completes.
+   */
+  template <typename MutableBufferSequence>
+  std::size_t read_some(const MutableBufferSequence& buffers,
+      boost::system::error_code& ec)
+  {
+    return this->impl_.get_service().read_some(
+        this->impl_.get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous read.
+  /**
+   * This function is used to asynchronously read data from the stream file.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the completion handler is called.
+   *
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes read.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @note The read operation may not read all of the requested number of bytes.
+   * Consider using the @ref async_read function if you need to ensure that the
+   * requested amount of data is read before the asynchronous operation
+   * completes.
+   *
+   * @par Example
+   * To read into a single data buffer use the @ref buffer function as follows:
+   * @code
+   * file.async_read_some(boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on reading into multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
+   */
+  template <typename MutableBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) ReadToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
+      void (boost::system::error_code, std::size_t))
+  async_read_some(const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+  {
+    return async_initiate<ReadToken,
+      void (boost::system::error_code, std::size_t)>(
+        initiate_async_read_some(this), token, buffers);
+  }
+
+private:
+  // Disallow copying and assignment.
+  basic_stream_file(const basic_stream_file&) BOOST_ASIO_DELETED;
+  basic_stream_file& operator=(const basic_stream_file&) BOOST_ASIO_DELETED;
+
+  class initiate_async_write_some
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_write_some(basic_stream_file* self)
+      : self_(self)
+    {
+    }
+
+    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename WriteHandler, typename ConstBufferSequence>
+    void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+        const ConstBufferSequence& buffers) const
+    {
+      // If you get an error on the following line it means that your handler
+      // does not meet the documented type requirements for a WriteHandler.
+      BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+      detail::non_const_lvalue<WriteHandler> handler2(handler);
+      self_->impl_.get_service().async_write_some(
+          self_->impl_.get_implementation(), buffers,
+          handler2.value, self_->impl_.get_executor());
+    }
+
+  private:
+    basic_stream_file* self_;
+  };
+
+  class initiate_async_read_some
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_read_some(basic_stream_file* self)
+      : self_(self)
+    {
+    }
+
+    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename ReadHandler, typename MutableBufferSequence>
+    void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+        const MutableBufferSequence& buffers) const
+    {
+      // If you get an error on the following line it means that your handler
+      // does not meet the documented type requirements for a ReadHandler.
+      BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+      detail::non_const_lvalue<ReadHandler> handler2(handler);
+      self_->impl_.get_service().async_read_some(
+          self_->impl_.get_implementation(), buffers,
+          handler2.value, self_->impl_.get_executor());
+    }
+
+  private:
+    basic_stream_file* self_;
+  };
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_BASIC_STREAM_FILE_HPP
diff --git a/boost/asio/basic_stream_socket.hpp b/boost/asio/basic_stream_socket.hpp
index 73de1699e44debc514e2796fe8af4751a2dcffb1..6764670399872855fa730d5e644391c899cdaa2c 100644
--- a/boost/asio/basic_stream_socket.hpp
+++ b/boost/asio/basic_stream_socket.hpp
@@ -2,7 +2,7 @@
 // basic_stream_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -439,25 +439,31 @@ public:
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send data on the stream socket.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The send operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
@@ -470,47 +476,63 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(this), handler,
+        initiate_async_send(this), token,
         buffers, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send data on the stream socket.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
+   * remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the send completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
+   *   std::size_t bytes_transferred // Number of bytes sent.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The send operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
@@ -523,21 +545,31 @@ public:
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(this), handler, buffers, flags);
+        initiate_async_send(this), token, buffers, flags);
   }
 
   /// Receive some data on the socket.
@@ -648,25 +680,31 @@ public:
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive data from the stream
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The receive operation may not receive all of the requested number of
    * bytes. Consider using the @ref async_read function if you need to ensure
    * that the requested amount of data is received before the asynchronous
@@ -681,47 +719,63 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(this), handler,
+        initiate_async_receive(this), token,
         buffers, socket_base::message_flags(0));
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive data from the stream
-   * socket. The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the receive completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
+   *   std::size_t bytes_transferred // Number of bytes received.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The receive operation may not receive all of the requested number of
    * bytes. Consider using the @ref async_read function if you need to ensure
    * that the requested amount of data is received before the asynchronous
@@ -736,21 +790,31 @@ public:
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(this), handler, buffers, flags);
+        initiate_async_receive(this), token, buffers, flags);
   }
 
   /// Write some data to the socket.
@@ -817,25 +881,31 @@ public:
   /// Start an asynchronous write.
   /**
    * This function is used to asynchronously write data to the stream socket.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be written to the socket.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the write operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes written.
+   *   std::size_t bytes_transferred // Number of bytes written.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
@@ -848,20 +918,30 @@ public:
    * See the @ref buffer documentation for information on writing multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_write_some(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_send(this), handler,
+        initiate_async_send(this), token,
         buffers, socket_base::message_flags(0));
   }
 
@@ -931,25 +1011,31 @@ public:
   /// Start an asynchronous read.
   /**
    * This function is used to asynchronously read data from the stream socket.
-   * The function call always returns immediately.
+   * socket. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be read.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the read operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes read.
+   *   std::size_t bytes_transferred // Number of bytes read.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
    * requested amount of data is read before the asynchronous operation
@@ -963,20 +1049,30 @@ public:
    * See the @ref buffer documentation for information on reading into multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * On POSIX or Windows operating systems, this asynchronous operation supports
+   * cancellation for the following boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_read_some(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_receive(this), handler,
+        initiate_async_receive(this), token,
         buffers, socket_base::message_flags(0));
   }
 
diff --git a/boost/asio/basic_streambuf.hpp b/boost/asio/basic_streambuf.hpp
index 897d13367d353d94460f40526fcc60d1521b2708..bfcc71e305fdb28c2b2ddb2000f8eea5c8a0e8a5 100644
--- a/boost/asio/basic_streambuf.hpp
+++ b/boost/asio/basic_streambuf.hpp
@@ -2,7 +2,7 @@
 // basic_streambuf.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/basic_streambuf_fwd.hpp b/boost/asio/basic_streambuf_fwd.hpp
index 3f88d36693272d771db6e92496a42093fedd0795..64260128fa8c8095a811a9ed83e26fbe7500ff0f 100644
--- a/boost/asio/basic_streambuf_fwd.hpp
+++ b/boost/asio/basic_streambuf_fwd.hpp
@@ -2,7 +2,7 @@
 // basic_streambuf_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/basic_waitable_timer.hpp b/boost/asio/basic_waitable_timer.hpp
index f1bcca9929933eb5948515f27061e6cd818717fa..da68c9c1b5ec8cf37f48989f9ab0a4d5af3e65c0 100644
--- a/boost/asio/basic_waitable_timer.hpp
+++ b/boost/asio/basic_waitable_timer.hpp
@@ -2,7 +2,7 @@
 // basic_waitable_timer.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -727,38 +727,54 @@ public:
   /// Start an asynchronous wait on the timer.
   /**
    * This function may be used to initiate an asynchronous wait against the
-   * timer. It always returns immediately.
+   * timer. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
-   * For each call to async_wait(), the supplied handler will be called exactly
-   * once. The handler will be called when:
+   * For each call to async_wait(), the completion handler will be called
+   * exactly once. The completion handler will be called when:
    *
    * @li The timer has expired.
    *
    * @li The timer was cancelled, in which case the handler is passed the error
    * code boost::asio::error::operation_aborted.
    *
-   * @param handler The handler to be called when the timer expires. Copies
-   * will be made of the handler as required. The function signature of the
-   * handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the timer expires. Potential
+   * completion tokens include @ref use_future, @ref use_awaitable, @ref
+   * yield_context, or a function object with the correct completion signature.
+   * The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
-        WaitHandler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitHandler,
+        WaitToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitToken,
       void (boost::system::error_code))
   async_wait(
-      BOOST_ASIO_MOVE_ARG(WaitHandler) handler
+      BOOST_ASIO_MOVE_ARG(WaitToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WaitHandler, void (boost::system::error_code)>(
-        initiate_async_wait(this), handler);
+    return async_initiate<WaitToken, void (boost::system::error_code)>(
+        initiate_async_wait(this), token);
   }
 
 private:
diff --git a/boost/asio/basic_writable_pipe.hpp b/boost/asio/basic_writable_pipe.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b883c23d604b02f0cc45e2bfbb3aece7813b933e
--- /dev/null
+++ b/boost/asio/basic_writable_pipe.hpp
@@ -0,0 +1,527 @@
+//
+// basic_writable_pipe.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_WRITABLE_PIPE_HPP
+#define BOOST_ASIO_BASIC_WRITABLE_PIPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_PIPE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <string>
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/io_object_impl.hpp>
+#include <boost/asio/detail/non_const_lvalue.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/execution_context.hpp>
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/win_iocp_handle_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/io_uring_descriptor_service.hpp>
+#else
+# include <boost/asio/detail/reactive_descriptor_service.hpp>
+#endif
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Provides pipe functionality.
+/**
+ * The basic_writable_pipe class provides a wrapper over pipe
+ * functionality.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <typename Executor = any_io_executor>
+class basic_writable_pipe
+{
+public:
+  /// The type of the executor associated with the object.
+  typedef Executor executor_type;
+
+  /// Rebinds the pipe type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The pipe type when rebound to the specified executor.
+    typedef basic_writable_pipe<Executor1> other;
+  };
+
+  /// The native representation of a pipe.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::win_iocp_handle_service::native_handle_type
+    native_handle_type;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  typedef detail::io_uring_descriptor_service::native_handle_type
+    native_handle_type;
+#else
+  typedef detail::reactive_descriptor_service::native_handle_type
+    native_handle_type;
+#endif
+
+  /// A basic_writable_pipe is always the lowest layer.
+  typedef basic_writable_pipe lowest_layer_type;
+
+  /// Construct a basic_writable_pipe without opening it.
+  /**
+   * This constructor creates a pipe without opening it.
+   *
+   * @param ex The I/O executor that the pipe will use, by default, to dispatch
+   * handlers for any asynchronous operations performed on the pipe.
+   */
+  explicit basic_writable_pipe(const executor_type& ex)
+    : impl_(0, ex)
+  {
+  }
+
+  /// Construct a basic_writable_pipe without opening it.
+  /**
+   * This constructor creates a pipe without opening it.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the pipe will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the pipe.
+   */
+  template <typename ExecutionContext>
+  explicit basic_writable_pipe(ExecutionContext& context,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
+  {
+  }
+
+  /// Construct a basic_writable_pipe on an existing native pipe.
+  /**
+   * This constructor creates a pipe object to hold an existing native
+   * pipe.
+   *
+   * @param ex The I/O executor that the pipe will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the
+   * pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  basic_writable_pipe(const executor_type& ex,
+      const native_handle_type& native_pipe)
+    : impl_(0, ex)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(impl_.get_implementation(),
+        native_pipe, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Construct a basic_writable_pipe on an existing native pipe.
+  /**
+   * This constructor creates a pipe object to hold an existing native
+   * pipe.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the pipe will use, by default, to dispatch handlers for any
+   * asynchronous operations performed on the pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename ExecutionContext>
+  basic_writable_pipe(ExecutionContext& context,
+      const native_handle_type& native_pipe,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value
+      >::type = 0)
+    : impl_(0, 0, context)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(impl_.get_implementation(),
+        native_pipe, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_writable_pipe from another.
+  /**
+   * This constructor moves a pipe from one object to another.
+   *
+   * @param other The other basic_writable_pipe object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_writable_pipe(const executor_type&)
+   * constructor.
+   */
+  basic_writable_pipe(basic_writable_pipe&& other)
+    : impl_(std::move(other.impl_))
+  {
+  }
+
+  /// Move-assign a basic_writable_pipe from another.
+  /**
+   * This assignment operator moves a pipe from one object to another.
+   *
+   * @param other The other basic_writable_pipe object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_writable_pipe(const executor_type&)
+   * constructor.
+   */
+  basic_writable_pipe& operator=(basic_writable_pipe&& other)
+  {
+    impl_ = std::move(other.impl_);
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destroys the pipe.
+  /**
+   * This function destroys the pipe, cancelling any outstanding
+   * asynchronous wait operations associated with the pipe as if by
+   * calling @c cancel.
+   */
+  ~basic_writable_pipe()
+  {
+  }
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() BOOST_ASIO_NOEXCEPT
+  {
+    return impl_.get_executor();
+  }
+
+  /// Get a reference to the lowest layer.
+  /**
+   * This function returns a reference to the lowest layer in a stack of
+   * layers. Since a basic_writable_pipe cannot contain any further layers, it
+   * simply returns a reference to itself.
+   *
+   * @return A reference to the lowest layer in the stack of layers. Ownership
+   * is not transferred to the caller.
+   */
+  lowest_layer_type& lowest_layer()
+  {
+    return *this;
+  }
+
+  /// Get a const reference to the lowest layer.
+  /**
+   * This function returns a const reference to the lowest layer in a stack of
+   * layers. Since a basic_writable_pipe cannot contain any further layers, it
+   * simply returns a reference to itself.
+   *
+   * @return A const reference to the lowest layer in the stack of layers.
+   * Ownership is not transferred to the caller.
+   */
+  const lowest_layer_type& lowest_layer() const
+  {
+    return *this;
+  }
+
+  /// Assign an existing native pipe to the pipe.
+  /*
+   * This function opens the pipe to hold an existing native pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void assign(const native_handle_type& native_pipe)
+  {
+    boost::system::error_code ec;
+    impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
+    boost::asio::detail::throw_error(ec, "assign");
+  }
+
+  /// Assign an existing native pipe to the pipe.
+  /*
+   * This function opens the pipe to hold an existing native pipe.
+   *
+   * @param native_pipe A native pipe.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID assign(const native_handle_type& native_pipe,
+      boost::system::error_code& ec)
+  {
+    impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Determine whether the pipe is open.
+  bool is_open() const
+  {
+    return impl_.get_service().is_open(impl_.get_implementation());
+  }
+
+  /// Close the pipe.
+  /**
+   * This function is used to close the pipe. Any asynchronous write operations
+   * will be cancelled immediately, and will complete with the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void close()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().close(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "close");
+  }
+
+  /// Close the pipe.
+  /**
+   * This function is used to close the pipe. Any asynchronous write operations
+   * will be cancelled immediately, and will complete with the
+   * boost::asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID close(boost::system::error_code& ec)
+  {
+    impl_.get_service().close(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Get the native pipe representation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * pipe. This is intended to allow access to native pipe
+   * functionality that is not otherwise provided.
+   */
+  native_handle_type native_handle()
+  {
+    return impl_.get_service().native_handle(impl_.get_implementation());
+  }
+
+  /// Cancel all asynchronous operations associated with the pipe.
+  /**
+   * This function causes all outstanding asynchronous write operations to
+   * finish immediately, and the handlers for cancelled operations will be
+   * passed the boost::asio::error::operation_aborted error.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void cancel()
+  {
+    boost::system::error_code ec;
+    impl_.get_service().cancel(impl_.get_implementation(), ec);
+    boost::asio::detail::throw_error(ec, "cancel");
+  }
+
+  /// Cancel all asynchronous operations associated with the pipe.
+  /**
+   * This function causes all outstanding asynchronous write operations to
+   * finish immediately, and the handlers for cancelled operations will be
+   * passed the boost::asio::error::operation_aborted error.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  BOOST_ASIO_SYNC_OP_VOID cancel(boost::system::error_code& ec)
+  {
+    impl_.get_service().cancel(impl_.get_implementation(), ec);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  /// Write some data to the pipe.
+  /**
+   * This function is used to write data to the pipe. The function call will
+   * block until one or more bytes of the data has been written successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the pipe.
+   *
+   * @returns The number of bytes written.
+   *
+   * @throws boost::system::system_error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The write_some operation may not transmit all of the data to the
+   * peer. Consider using the @ref write function if you need to ensure that
+   * all data is written before the blocking operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * pipe.write_some(boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on writing multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some(const ConstBufferSequence& buffers)
+  {
+    boost::system::error_code ec;
+    std::size_t s = impl_.get_service().write_some(
+        impl_.get_implementation(), buffers, ec);
+    boost::asio::detail::throw_error(ec, "write_some");
+    return s;
+  }
+
+  /// Write some data to the pipe.
+  /**
+   * This function is used to write data to the pipe. The function call will
+   * block until one or more bytes of the data has been written successfully,
+   * or until an error occurs.
+   *
+   * @param buffers One or more data buffers to be written to the pipe.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   *
+   * @returns The number of bytes written. Returns 0 if an error occurred.
+   *
+   * @note The write_some operation may not transmit all of the data to the
+   * peer. Consider using the @ref write function if you need to ensure that
+   * all data is written before the blocking operation completes.
+   */
+  template <typename ConstBufferSequence>
+  std::size_t write_some(const ConstBufferSequence& buffers,
+      boost::system::error_code& ec)
+  {
+    return impl_.get_service().write_some(
+        impl_.get_implementation(), buffers, ec);
+  }
+
+  /// Start an asynchronous write.
+  /**
+   * This function is used to asynchronously write data to the pipe. It is an
+   * initiating function for an @ref asynchronous_operation, and always returns
+   * immediately.
+   *
+   * @param buffers One or more data buffers to be written to the pipe.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the completion handler is called.
+   *
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
+   * @code void handler(
+   *   const boost::system::error_code& error, // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes written.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @note The write operation may not transmit all of the data to the peer.
+   * Consider using the @ref async_write function if you need to ensure that all
+   * data is written before the asynchronous operation completes.
+   *
+   * @par Example
+   * To write a single data buffer use the @ref buffer function as follows:
+   * @code
+   * pipe.async_write_some(boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on writing multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename ConstBufferSequence,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+        std::size_t)) WriteToken
+          BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
+      void (boost::system::error_code, std::size_t))
+  async_write_some(const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+  {
+    return async_initiate<WriteToken,
+      void (boost::system::error_code, std::size_t)>(
+        initiate_async_write_some(this), token, buffers);
+  }
+
+private:
+  // Disallow copying and assignment.
+  basic_writable_pipe(const basic_writable_pipe&) BOOST_ASIO_DELETED;
+  basic_writable_pipe& operator=(const basic_writable_pipe&) BOOST_ASIO_DELETED;
+
+  class initiate_async_write_some
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_write_some(basic_writable_pipe* self)
+      : self_(self)
+    {
+    }
+
+    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename WriteHandler, typename ConstBufferSequence>
+    void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+        const ConstBufferSequence& buffers) const
+    {
+      // If you get an error on the following line it means that your handler
+      // does not meet the documented type requirements for a WriteHandler.
+      BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+      detail::non_const_lvalue<WriteHandler> handler2(handler);
+      self_->impl_.get_service().async_write_some(
+          self_->impl_.get_implementation(), buffers,
+          handler2.value, self_->impl_.get_executor());
+    }
+
+  private:
+    basic_writable_pipe* self_;
+  };
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+  detail::io_object_impl<detail::win_iocp_handle_service, Executor> impl_;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  detail::io_object_impl<detail::io_uring_descriptor_service, Executor> impl_;
+#else
+  detail::io_object_impl<detail::reactive_descriptor_service, Executor> impl_;
+#endif
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_PIPE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_BASIC_WRITABLE_PIPE_HPP
diff --git a/boost/asio/bind_allocator.hpp b/boost/asio/bind_allocator.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..42c0ae86ccbb71275e6287e830052a0ac36e1a24
--- /dev/null
+++ b/boost/asio/bind_allocator.hpp
@@ -0,0 +1,724 @@
+//
+// bind_allocator.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BIND_ALLOCATOR_HPP
+#define BOOST_ASIO_BIND_ALLOCATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
+#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/async_result.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Helper to automatically define nested typedef result_type.
+
+template <typename T, typename = void>
+struct allocator_binder_result_type
+{
+protected:
+  typedef void result_type_or_void;
+};
+
+template <typename T>
+struct allocator_binder_result_type<T,
+  typename void_type<typename T::result_type>::type>
+{
+  typedef typename T::result_type result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R>
+struct allocator_binder_result_type<R(*)()>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R>
+struct allocator_binder_result_type<R(&)()>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1>
+struct allocator_binder_result_type<R(*)(A1)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1>
+struct allocator_binder_result_type<R(&)(A1)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1, typename A2>
+struct allocator_binder_result_type<R(*)(A1, A2)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1, typename A2>
+struct allocator_binder_result_type<R(&)(A1, A2)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+// Helper to automatically define nested typedef argument_type.
+
+template <typename T, typename = void>
+struct allocator_binder_argument_type {};
+
+template <typename T>
+struct allocator_binder_argument_type<T,
+  typename void_type<typename T::argument_type>::type>
+{
+  typedef typename T::argument_type argument_type;
+};
+
+template <typename R, typename A1>
+struct allocator_binder_argument_type<R(*)(A1)>
+{
+  typedef A1 argument_type;
+};
+
+template <typename R, typename A1>
+struct allocator_binder_argument_type<R(&)(A1)>
+{
+  typedef A1 argument_type;
+};
+
+// Helper to automatically define nested typedefs first_argument_type and
+// second_argument_type.
+
+template <typename T, typename = void>
+struct allocator_binder_argument_types {};
+
+template <typename T>
+struct allocator_binder_argument_types<T,
+  typename void_type<typename T::first_argument_type>::type>
+{
+  typedef typename T::first_argument_type first_argument_type;
+  typedef typename T::second_argument_type second_argument_type;
+};
+
+template <typename R, typename A1, typename A2>
+struct allocator_binder_argument_type<R(*)(A1, A2)>
+{
+  typedef A1 first_argument_type;
+  typedef A2 second_argument_type;
+};
+
+template <typename R, typename A1, typename A2>
+struct allocator_binder_argument_type<R(&)(A1, A2)>
+{
+  typedef A1 first_argument_type;
+  typedef A2 second_argument_type;
+};
+
+// Helper to enable SFINAE on zero-argument operator() below.
+
+template <typename T, typename = void>
+struct allocator_binder_result_of0
+{
+  typedef void type;
+};
+
+template <typename T>
+struct allocator_binder_result_of0<T,
+  typename void_type<typename result_of<T()>::type>::type>
+{
+  typedef typename result_of<T()>::type type;
+};
+
+} // namespace detail
+
+/// A call wrapper type to bind an allocator of type @c Allocator
+/// to an object of type @c T.
+template <typename T, typename Allocator>
+class allocator_binder
+#if !defined(GENERATING_DOCUMENTATION)
+  : public detail::allocator_binder_result_type<T>,
+    public detail::allocator_binder_argument_type<T>,
+    public detail::allocator_binder_argument_types<T>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+public:
+  /// The type of the target object.
+  typedef T target_type;
+
+  /// The type of the associated allocator.
+  typedef Allocator allocator_type;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// The return type if a function.
+  /**
+   * The type of @c result_type is based on the type @c T of the wrapper's
+   * target object:
+   *
+   * @li if @c T is a pointer to function type, @c result_type is a synonym for
+   * the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c result_type, then @c
+   * result_type is a synonym for @c T::result_type;
+   *
+   * @li otherwise @c result_type is not defined.
+   */
+  typedef see_below result_type;
+
+  /// The type of the function's argument.
+  /**
+   * The type of @c argument_type is based on the type @c T of the wrapper's
+   * target object:
+   *
+   * @li if @c T is a pointer to a function type accepting a single argument,
+   * @c argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c argument_type, then @c
+   * argument_type is a synonym for @c T::argument_type;
+   *
+   * @li otherwise @c argument_type is not defined.
+   */
+  typedef see_below argument_type;
+
+  /// The type of the function's first argument.
+  /**
+   * The type of @c first_argument_type is based on the type @c T of the
+   * wrapper's target object:
+   *
+   * @li if @c T is a pointer to a function type accepting two arguments, @c
+   * first_argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c first_argument_type,
+   * then @c first_argument_type is a synonym for @c T::first_argument_type;
+   *
+   * @li otherwise @c first_argument_type is not defined.
+   */
+  typedef see_below first_argument_type;
+
+  /// The type of the function's second argument.
+  /**
+   * The type of @c second_argument_type is based on the type @c T of the
+   * wrapper's target object:
+   *
+   * @li if @c T is a pointer to a function type accepting two arguments, @c
+   * second_argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c first_argument_type,
+   * then @c second_argument_type is a synonym for @c T::second_argument_type;
+   *
+   * @li otherwise @c second_argument_type is not defined.
+   */
+  typedef see_below second_argument_type;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Construct an allocator wrapper for the specified object.
+  /**
+   * This constructor is only valid if the type @c T is constructible from type
+   * @c U.
+   */
+  template <typename U>
+  allocator_binder(const allocator_type& s,
+      BOOST_ASIO_MOVE_ARG(U) u)
+    : allocator_(s),
+      target_(BOOST_ASIO_MOVE_CAST(U)(u))
+  {
+  }
+
+  /// Copy constructor.
+  allocator_binder(const allocator_binder& other)
+    : allocator_(other.get_allocator()),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy, but specify a different allocator.
+  allocator_binder(const allocator_type& s,
+      const allocator_binder& other)
+    : allocator_(s),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy of a different allocator wrapper type.
+  /**
+   * This constructor is only valid if the @c Allocator type is
+   * constructible from type @c OtherAllocator, and the type @c T is
+   * constructible from type @c U.
+   */
+  template <typename U, typename OtherAllocator>
+  allocator_binder(
+      const allocator_binder<U, OtherAllocator>& other)
+    : allocator_(other.get_allocator()),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy of a different allocator wrapper type, but
+  /// specify a different allocator.
+  /**
+   * This constructor is only valid if the type @c T is constructible from type
+   * @c U.
+   */
+  template <typename U, typename OtherAllocator>
+  allocator_binder(const allocator_type& s,
+      const allocator_binder<U, OtherAllocator>& other)
+    : allocator_(s),
+      target_(other.get())
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Move constructor.
+  allocator_binder(allocator_binder&& other)
+    : allocator_(BOOST_ASIO_MOVE_CAST(allocator_type)(
+          other.get_allocator())),
+      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+  {
+  }
+
+  /// Move construct the target object, but specify a different allocator.
+  allocator_binder(const allocator_type& s,
+      allocator_binder&& other)
+    : allocator_(s),
+      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+  {
+  }
+
+  /// Move construct from a different allocator wrapper type.
+  template <typename U, typename OtherAllocator>
+  allocator_binder(
+      allocator_binder<U, OtherAllocator>&& other)
+    : allocator_(BOOST_ASIO_MOVE_CAST(OtherAllocator)(
+          other.get_allocator())),
+      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+  {
+  }
+
+  /// Move construct from a different allocator wrapper type, but
+  /// specify a different allocator.
+  template <typename U, typename OtherAllocator>
+  allocator_binder(const allocator_type& s,
+      allocator_binder<U, OtherAllocator>&& other)
+    : allocator_(s),
+      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+  {
+  }
+
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destructor.
+  ~allocator_binder()
+  {
+  }
+
+  /// Obtain a reference to the target object.
+  target_type& get() BOOST_ASIO_NOEXCEPT
+  {
+    return target_;
+  }
+
+  /// Obtain a reference to the target object.
+  const target_type& get() const BOOST_ASIO_NOEXCEPT
+  {
+    return target_;
+  }
+
+  /// Obtain the associated allocator.
+  allocator_type get_allocator() const BOOST_ASIO_NOEXCEPT
+  {
+    return allocator_;
+  }
+
+#if defined(GENERATING_DOCUMENTATION)
+
+  template <typename... Args> auto operator()(Args&& ...);
+  template <typename... Args> auto operator()(Args&& ...) const;
+
+#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  /// Forwarding function call operator.
+  template <typename... Args>
+  typename result_of<T(Args...)>::type operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+  /// Forwarding function call operator.
+  template <typename... Args>
+  typename result_of<T(Args...)>::type operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args) const
+  {
+    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#elif defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+  typename detail::allocator_binder_result_of0<T>::type operator()()
+  {
+    return target_();
+  }
+
+  typename detail::allocator_binder_result_of0<T>::type
+  operator()() const
+  {
+    return target_();
+  }
+
+#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
+#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
+
+#else // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+  typedef typename detail::allocator_binder_result_type<
+    T>::result_type_or_void result_type_or_void;
+
+  result_type_or_void operator()()
+  {
+    return target_();
+  }
+
+  result_type_or_void operator()() const
+  {
+    return target_();
+  }
+
+#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  result_type_or_void operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  result_type_or_void operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
+#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
+
+#endif // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+private:
+  Allocator allocator_;
+  T target_;
+};
+
+/// Associate an object of type @c T with an allocator of type
+/// @c Allocator.
+template <typename Allocator, typename T>
+BOOST_ASIO_NODISCARD inline allocator_binder<typename decay<T>::type, Allocator>
+bind_allocator(const Allocator& s, BOOST_ASIO_MOVE_ARG(T) t)
+{
+  return allocator_binder<
+    typename decay<T>::type, Allocator>(
+      s, BOOST_ASIO_MOVE_CAST(T)(t));
+}
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+namespace detail {
+
+template <typename TargetAsyncResult,
+  typename Allocator, typename = void>
+struct allocator_binder_async_result_completion_handler_type
+{
+};
+
+template <typename TargetAsyncResult, typename Allocator>
+struct allocator_binder_async_result_completion_handler_type<
+  TargetAsyncResult, Allocator,
+  typename void_type<
+    typename TargetAsyncResult::completion_handler_type
+  >::type>
+{
+  typedef allocator_binder<
+    typename TargetAsyncResult::completion_handler_type, Allocator>
+      completion_handler_type;
+};
+
+template <typename TargetAsyncResult, typename = void>
+struct allocator_binder_async_result_return_type
+{
+};
+
+template <typename TargetAsyncResult>
+struct allocator_binder_async_result_return_type<
+  TargetAsyncResult,
+  typename void_type<
+    typename TargetAsyncResult::return_type
+  >::type>
+{
+  typedef typename TargetAsyncResult::return_type return_type;
+};
+
+} // namespace detail
+
+template <typename T, typename Allocator, typename Signature>
+class async_result<allocator_binder<T, Allocator>, Signature> :
+  public detail::allocator_binder_async_result_completion_handler_type<
+    async_result<T, Signature>, Allocator>,
+  public detail::allocator_binder_async_result_return_type<
+    async_result<T, Signature> >
+{
+public:
+  explicit async_result(allocator_binder<T, Allocator>& b)
+    : target_(b.get())
+  {
+  }
+
+  typename async_result<T, Signature>::return_type get()
+  {
+    return target_.get();
+  }
+
+  template <typename Initiation>
+  struct init_wrapper
+  {
+    template <typename Init>
+    init_wrapper(const Allocator& allocator, BOOST_ASIO_MOVE_ARG(Init) init)
+      : allocator_(allocator),
+        initiation_(BOOST_ASIO_MOVE_CAST(Init)(init))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          allocator_binder<
+            typename decay<Handler>::type, Allocator>(
+              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args) const
+    {
+      initiation_(
+          allocator_binder<
+            typename decay<Handler>::type, Allocator>(
+              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          allocator_binder<
+            typename decay<Handler>::type, Allocator>(
+              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler) const
+    {
+      initiation_(
+          allocator_binder<
+            typename decay<Handler>::type, Allocator>(
+              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+#define BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF(n) \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+    { \
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)( \
+          allocator_binder< \
+            typename decay<Handler>::type, Allocator>( \
+              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+    { \
+      initiation_( \
+          allocator_binder< \
+            typename decay<Handler>::type, Allocator>( \
+              allocator_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    /**/
+    BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF)
+#undef BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    Allocator allocator_;
+    Initiation initiation_;
+  };
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get(),
+        declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_allocator(),
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get(), BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get())))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_allocator(),
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get());
+  }
+
+#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
+  template <typename Initiation, typename RawCompletionToken, \
+      BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, \
+    (async_initiate<T, Signature>( \
+        declval<init_wrapper<typename decay<Initiation>::type> >(), \
+        declval<RawCompletionToken>().get(), \
+        BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n)))) \
+  initiate( \
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token, \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return async_initiate<T, Signature>( \
+        init_wrapper<typename decay<Initiation>::type>( \
+          token.get_allocator(), \
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)), \
+        token.get(), 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:
+  async_result(const async_result&) BOOST_ASIO_DELETED;
+  async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
+
+  async_result<T, Signature> target_;
+};
+
+template <template <typename, typename> class Associator,
+    typename T, typename Allocator, typename DefaultCandidate>
+struct associator<Associator,
+    allocator_binder<T, Allocator>,
+    DefaultCandidate>
+{
+  typedef typename Associator<T, DefaultCandidate>::type type;
+
+  static type get(const allocator_binder<T, Allocator>& b,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<T, DefaultCandidate>::get(b.get(), c);
+  }
+};
+
+template <typename T, typename Allocator, typename Allocator1>
+struct associated_allocator<
+    allocator_binder<T, Allocator>,
+    Allocator1>
+{
+  typedef Allocator type;
+
+  static type get(const allocator_binder<T, Allocator>& b,
+      const Allocator1& = Allocator1()) BOOST_ASIO_NOEXCEPT
+  {
+    return b.get_allocator();
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BIND_ALLOCATOR_HPP
diff --git a/boost/asio/bind_cancellation_slot.hpp b/boost/asio/bind_cancellation_slot.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..eafb8ec403e2a7bdb402bd9973db34e1999ce218
--- /dev/null
+++ b/boost/asio/bind_cancellation_slot.hpp
@@ -0,0 +1,726 @@
+//
+// bind_cancellation_slot.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BIND_CANCELLATION_SLOT_HPP
+#define BOOST_ASIO_BIND_CANCELLATION_SLOT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/async_result.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Helper to automatically define nested typedef result_type.
+
+template <typename T, typename = void>
+struct cancellation_slot_binder_result_type
+{
+protected:
+  typedef void result_type_or_void;
+};
+
+template <typename T>
+struct cancellation_slot_binder_result_type<T,
+  typename void_type<typename T::result_type>::type>
+{
+  typedef typename T::result_type result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R>
+struct cancellation_slot_binder_result_type<R(*)()>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R>
+struct cancellation_slot_binder_result_type<R(&)()>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1>
+struct cancellation_slot_binder_result_type<R(*)(A1)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1>
+struct cancellation_slot_binder_result_type<R(&)(A1)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1, typename A2>
+struct cancellation_slot_binder_result_type<R(*)(A1, A2)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+template <typename R, typename A1, typename A2>
+struct cancellation_slot_binder_result_type<R(&)(A1, A2)>
+{
+  typedef R result_type;
+protected:
+  typedef result_type result_type_or_void;
+};
+
+// Helper to automatically define nested typedef argument_type.
+
+template <typename T, typename = void>
+struct cancellation_slot_binder_argument_type {};
+
+template <typename T>
+struct cancellation_slot_binder_argument_type<T,
+  typename void_type<typename T::argument_type>::type>
+{
+  typedef typename T::argument_type argument_type;
+};
+
+template <typename R, typename A1>
+struct cancellation_slot_binder_argument_type<R(*)(A1)>
+{
+  typedef A1 argument_type;
+};
+
+template <typename R, typename A1>
+struct cancellation_slot_binder_argument_type<R(&)(A1)>
+{
+  typedef A1 argument_type;
+};
+
+// Helper to automatically define nested typedefs first_argument_type and
+// second_argument_type.
+
+template <typename T, typename = void>
+struct cancellation_slot_binder_argument_types {};
+
+template <typename T>
+struct cancellation_slot_binder_argument_types<T,
+  typename void_type<typename T::first_argument_type>::type>
+{
+  typedef typename T::first_argument_type first_argument_type;
+  typedef typename T::second_argument_type second_argument_type;
+};
+
+template <typename R, typename A1, typename A2>
+struct cancellation_slot_binder_argument_type<R(*)(A1, A2)>
+{
+  typedef A1 first_argument_type;
+  typedef A2 second_argument_type;
+};
+
+template <typename R, typename A1, typename A2>
+struct cancellation_slot_binder_argument_type<R(&)(A1, A2)>
+{
+  typedef A1 first_argument_type;
+  typedef A2 second_argument_type;
+};
+
+// Helper to enable SFINAE on zero-argument operator() below.
+
+template <typename T, typename = void>
+struct cancellation_slot_binder_result_of0
+{
+  typedef void type;
+};
+
+template <typename T>
+struct cancellation_slot_binder_result_of0<T,
+  typename void_type<typename result_of<T()>::type>::type>
+{
+  typedef typename result_of<T()>::type type;
+};
+
+} // namespace detail
+
+/// A call wrapper type to bind a cancellation slot of type @c CancellationSlot
+/// to an object of type @c T.
+template <typename T, typename CancellationSlot>
+class cancellation_slot_binder
+#if !defined(GENERATING_DOCUMENTATION)
+  : public detail::cancellation_slot_binder_result_type<T>,
+    public detail::cancellation_slot_binder_argument_type<T>,
+    public detail::cancellation_slot_binder_argument_types<T>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+public:
+  /// The type of the target object.
+  typedef T target_type;
+
+  /// The type of the associated cancellation slot.
+  typedef CancellationSlot cancellation_slot_type;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// The return type if a function.
+  /**
+   * The type of @c result_type is based on the type @c T of the wrapper's
+   * target object:
+   *
+   * @li if @c T is a pointer to function type, @c result_type is a synonym for
+   * the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c result_type, then @c
+   * result_type is a synonym for @c T::result_type;
+   *
+   * @li otherwise @c result_type is not defined.
+   */
+  typedef see_below result_type;
+
+  /// The type of the function's argument.
+  /**
+   * The type of @c argument_type is based on the type @c T of the wrapper's
+   * target object:
+   *
+   * @li if @c T is a pointer to a function type accepting a single argument,
+   * @c argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c argument_type, then @c
+   * argument_type is a synonym for @c T::argument_type;
+   *
+   * @li otherwise @c argument_type is not defined.
+   */
+  typedef see_below argument_type;
+
+  /// The type of the function's first argument.
+  /**
+   * The type of @c first_argument_type is based on the type @c T of the
+   * wrapper's target object:
+   *
+   * @li if @c T is a pointer to a function type accepting two arguments, @c
+   * first_argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c first_argument_type,
+   * then @c first_argument_type is a synonym for @c T::first_argument_type;
+   *
+   * @li otherwise @c first_argument_type is not defined.
+   */
+  typedef see_below first_argument_type;
+
+  /// The type of the function's second argument.
+  /**
+   * The type of @c second_argument_type is based on the type @c T of the
+   * wrapper's target object:
+   *
+   * @li if @c T is a pointer to a function type accepting two arguments, @c
+   * second_argument_type is a synonym for the return type of @c T;
+   *
+   * @li if @c T is a class type with a member type @c first_argument_type,
+   * then @c second_argument_type is a synonym for @c T::second_argument_type;
+   *
+   * @li otherwise @c second_argument_type is not defined.
+   */
+  typedef see_below second_argument_type;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Construct a cancellation slot wrapper for the specified object.
+  /**
+   * This constructor is only valid if the type @c T is constructible from type
+   * @c U.
+   */
+  template <typename U>
+  cancellation_slot_binder(const cancellation_slot_type& s,
+      BOOST_ASIO_MOVE_ARG(U) u)
+    : slot_(s),
+      target_(BOOST_ASIO_MOVE_CAST(U)(u))
+  {
+  }
+
+  /// Copy constructor.
+  cancellation_slot_binder(const cancellation_slot_binder& other)
+    : slot_(other.get_cancellation_slot()),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy, but specify a different cancellation slot.
+  cancellation_slot_binder(const cancellation_slot_type& s,
+      const cancellation_slot_binder& other)
+    : slot_(s),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy of a different cancellation slot wrapper type.
+  /**
+   * This constructor is only valid if the @c CancellationSlot type is
+   * constructible from type @c OtherCancellationSlot, and the type @c T is
+   * constructible from type @c U.
+   */
+  template <typename U, typename OtherCancellationSlot>
+  cancellation_slot_binder(
+      const cancellation_slot_binder<U, OtherCancellationSlot>& other)
+    : slot_(other.get_cancellation_slot()),
+      target_(other.get())
+  {
+  }
+
+  /// Construct a copy of a different cancellation slot wrapper type, but
+  /// specify a different cancellation slot.
+  /**
+   * This constructor is only valid if the type @c T is constructible from type
+   * @c U.
+   */
+  template <typename U, typename OtherCancellationSlot>
+  cancellation_slot_binder(const cancellation_slot_type& s,
+      const cancellation_slot_binder<U, OtherCancellationSlot>& other)
+    : slot_(s),
+      target_(other.get())
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Move constructor.
+  cancellation_slot_binder(cancellation_slot_binder&& other)
+    : slot_(BOOST_ASIO_MOVE_CAST(cancellation_slot_type)(
+          other.get_cancellation_slot())),
+      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+  {
+  }
+
+  /// Move construct the target object, but specify a different cancellation
+  /// slot.
+  cancellation_slot_binder(const cancellation_slot_type& s,
+      cancellation_slot_binder&& other)
+    : slot_(s),
+      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+  {
+  }
+
+  /// Move construct from a different cancellation slot wrapper type.
+  template <typename U, typename OtherCancellationSlot>
+  cancellation_slot_binder(
+      cancellation_slot_binder<U, OtherCancellationSlot>&& other)
+    : slot_(BOOST_ASIO_MOVE_CAST(OtherCancellationSlot)(
+          other.get_cancellation_slot())),
+      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+  {
+  }
+
+  /// Move construct from a different cancellation slot wrapper type, but
+  /// specify a different cancellation slot.
+  template <typename U, typename OtherCancellationSlot>
+  cancellation_slot_binder(const cancellation_slot_type& s,
+      cancellation_slot_binder<U, OtherCancellationSlot>&& other)
+    : slot_(s),
+      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+  {
+  }
+
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destructor.
+  ~cancellation_slot_binder()
+  {
+  }
+
+  /// Obtain a reference to the target object.
+  target_type& get() BOOST_ASIO_NOEXCEPT
+  {
+    return target_;
+  }
+
+  /// Obtain a reference to the target object.
+  const target_type& get() const BOOST_ASIO_NOEXCEPT
+  {
+    return target_;
+  }
+
+  /// Obtain the associated cancellation slot.
+  cancellation_slot_type get_cancellation_slot() const BOOST_ASIO_NOEXCEPT
+  {
+    return slot_;
+  }
+
+#if defined(GENERATING_DOCUMENTATION)
+
+  template <typename... Args> auto operator()(Args&& ...);
+  template <typename... Args> auto operator()(Args&& ...) const;
+
+#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  /// Forwarding function call operator.
+  template <typename... Args>
+  typename result_of<T(Args...)>::type operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+  /// Forwarding function call operator.
+  template <typename... Args>
+  typename result_of<T(Args...)>::type operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args) const
+  {
+    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#elif defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+  typename detail::cancellation_slot_binder_result_of0<T>::type operator()()
+  {
+    return target_();
+  }
+
+  typename detail::cancellation_slot_binder_result_of0<T>::type
+  operator()() const
+  {
+    return target_();
+  }
+
+#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
+#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
+
+#else // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+  typedef typename detail::cancellation_slot_binder_result_type<
+    T>::result_type_or_void result_type_or_void;
+
+  result_type_or_void operator()()
+  {
+    return target_();
+  }
+
+  result_type_or_void operator()() const
+  {
+    return target_();
+  }
+
+#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  result_type_or_void operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  result_type_or_void operator()( \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+  { \
+    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
+#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
+
+#endif // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
+
+private:
+  CancellationSlot slot_;
+  T target_;
+};
+
+/// Associate an object of type @c T with a cancellation slot of type
+/// @c CancellationSlot.
+template <typename CancellationSlot, typename T>
+BOOST_ASIO_NODISCARD inline
+cancellation_slot_binder<typename decay<T>::type, CancellationSlot>
+bind_cancellation_slot(const CancellationSlot& s, BOOST_ASIO_MOVE_ARG(T) t)
+{
+  return cancellation_slot_binder<
+    typename decay<T>::type, CancellationSlot>(
+      s, BOOST_ASIO_MOVE_CAST(T)(t));
+}
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+namespace detail {
+
+template <typename TargetAsyncResult,
+  typename CancellationSlot, typename = void>
+struct cancellation_slot_binder_async_result_completion_handler_type
+{
+};
+
+template <typename TargetAsyncResult, typename CancellationSlot>
+struct cancellation_slot_binder_async_result_completion_handler_type<
+  TargetAsyncResult, CancellationSlot,
+  typename void_type<
+    typename TargetAsyncResult::completion_handler_type
+  >::type>
+{
+  typedef cancellation_slot_binder<
+    typename TargetAsyncResult::completion_handler_type, CancellationSlot>
+      completion_handler_type;
+};
+
+template <typename TargetAsyncResult, typename = void>
+struct cancellation_slot_binder_async_result_return_type
+{
+};
+
+template <typename TargetAsyncResult>
+struct cancellation_slot_binder_async_result_return_type<
+  TargetAsyncResult,
+  typename void_type<
+    typename TargetAsyncResult::return_type
+  >::type>
+{
+  typedef typename TargetAsyncResult::return_type return_type;
+};
+
+} // namespace detail
+
+template <typename T, typename CancellationSlot, typename Signature>
+class async_result<cancellation_slot_binder<T, CancellationSlot>, Signature> :
+  public detail::cancellation_slot_binder_async_result_completion_handler_type<
+    async_result<T, Signature>, CancellationSlot>,
+  public detail::cancellation_slot_binder_async_result_return_type<
+    async_result<T, Signature> >
+{
+public:
+  explicit async_result(cancellation_slot_binder<T, CancellationSlot>& b)
+    : target_(b.get())
+  {
+  }
+
+  typename async_result<T, Signature>::return_type get()
+  {
+    return target_.get();
+  }
+
+  template <typename Initiation>
+  struct init_wrapper
+  {
+    template <typename Init>
+    init_wrapper(const CancellationSlot& slot, BOOST_ASIO_MOVE_ARG(Init) init)
+      : slot_(slot),
+        initiation_(BOOST_ASIO_MOVE_CAST(Init)(init))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          cancellation_slot_binder<
+            typename decay<Handler>::type, CancellationSlot>(
+              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args) const
+    {
+      initiation_(
+          cancellation_slot_binder<
+            typename decay<Handler>::type, CancellationSlot>(
+              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          cancellation_slot_binder<
+            typename decay<Handler>::type, CancellationSlot>(
+              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler) const
+    {
+      initiation_(
+          cancellation_slot_binder<
+            typename decay<Handler>::type, CancellationSlot>(
+              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+#define BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF(n) \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+    { \
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)( \
+          cancellation_slot_binder< \
+            typename decay<Handler>::type, CancellationSlot>( \
+              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+    { \
+      initiation_( \
+          cancellation_slot_binder< \
+            typename decay<Handler>::type, CancellationSlot>( \
+              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    /**/
+    BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF)
+#undef BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    CancellationSlot slot_;
+    Initiation initiation_;
+  };
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get(),
+        declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_cancellation_slot(),
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get(), BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get())))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_cancellation_slot(),
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get());
+  }
+
+#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
+  template <typename Initiation, typename RawCompletionToken, \
+      BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, \
+    (async_initiate<T, Signature>( \
+        declval<init_wrapper<typename decay<Initiation>::type> >(), \
+        declval<RawCompletionToken>().get(), \
+        BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n)))) \
+  initiate( \
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token, \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return async_initiate<T, Signature>( \
+        init_wrapper<typename decay<Initiation>::type>( \
+          token.get_cancellation_slot(), \
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)), \
+        token.get(), 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:
+  async_result(const async_result&) BOOST_ASIO_DELETED;
+  async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
+
+  async_result<T, Signature> target_;
+};
+
+template <template <typename, typename> class Associator,
+    typename T, typename CancellationSlot, typename DefaultCandidate>
+struct associator<Associator,
+    cancellation_slot_binder<T, CancellationSlot>,
+    DefaultCandidate>
+{
+  typedef typename Associator<T, DefaultCandidate>::type type;
+
+  static type get(const cancellation_slot_binder<T, CancellationSlot>& b,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<T, DefaultCandidate>::get(b.get(), c);
+  }
+};
+
+template <typename T, typename CancellationSlot, typename CancellationSlot1>
+struct associated_cancellation_slot<
+    cancellation_slot_binder<T, CancellationSlot>,
+    CancellationSlot1>
+{
+  typedef CancellationSlot type;
+
+  static type get(const cancellation_slot_binder<T, CancellationSlot>& b,
+      const CancellationSlot1& = CancellationSlot1()) BOOST_ASIO_NOEXCEPT
+  {
+    return b.get_cancellation_slot();
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BIND_CANCELLATION_SLOT_HPP
diff --git a/boost/asio/bind_executor.hpp b/boost/asio/bind_executor.hpp
index 28b11667dca5b0e548a9c5056a50b0de145ec628..5e0f08fd592a6a6ddac6df54f763745875aea034 100644
--- a/boost/asio/bind_executor.hpp
+++ b/boost/asio/bind_executor.hpp
@@ -2,7 +2,7 @@
 // bind_executor.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,7 +19,7 @@
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/detail/variadic_templates.hpp>
 #include <boost/asio/associated_executor.hpp>
-#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/execution/executor.hpp>
 #include <boost/asio/execution_context.hpp>
@@ -487,7 +487,7 @@ private:
 
 /// Associate an object of type @c T with an executor of type @c Executor.
 template <typename Executor, typename T>
-inline executor_binder<typename decay<T>::type, Executor>
+BOOST_ASIO_NODISCARD inline executor_binder<typename decay<T>::type, Executor>
 bind_executor(const Executor& ex, BOOST_ASIO_MOVE_ARG(T) t,
     typename constraint<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
@@ -499,7 +499,7 @@ bind_executor(const Executor& ex, BOOST_ASIO_MOVE_ARG(T) t,
 
 /// Associate an object of type @c T with an execution context's executor.
 template <typename ExecutionContext, typename T>
-inline executor_binder<typename decay<T>::type,
+BOOST_ASIO_NODISCARD inline executor_binder<typename decay<T>::type,
   typename ExecutionContext::executor_type>
 bind_executor(ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(T) t,
     typename constraint<is_convertible<
@@ -516,42 +516,237 @@ template <typename T, typename Executor>
 struct uses_executor<executor_binder<T, Executor>, Executor>
   : true_type {};
 
-template <typename T, typename Executor, typename Signature>
-class async_result<executor_binder<T, Executor>, Signature>
+namespace detail {
+
+template <typename TargetAsyncResult, typename Executor, typename = void>
+class executor_binder_completion_handler_async_result
+{
+public:
+  template <typename T>
+  explicit executor_binder_completion_handler_async_result(T&)
+  {
+  }
+};
+
+template <typename TargetAsyncResult, typename Executor>
+class executor_binder_completion_handler_async_result<
+  TargetAsyncResult, Executor,
+  typename void_type<
+    typename TargetAsyncResult::completion_handler_type
+  >::type>
 {
 public:
   typedef executor_binder<
-    typename async_result<T, Signature>::completion_handler_type, Executor>
+    typename TargetAsyncResult::completion_handler_type, Executor>
       completion_handler_type;
 
-  typedef typename async_result<T, Signature>::return_type return_type;
+  explicit executor_binder_completion_handler_async_result(
+      typename TargetAsyncResult::completion_handler_type& handler)
+    : target_(handler)
+  {
+  }
+
+  typename TargetAsyncResult::return_type get()
+  {
+    return target_.get();
+  }
 
+private:
+  TargetAsyncResult target_;
+};
+
+template <typename TargetAsyncResult, typename = void>
+struct executor_binder_async_result_return_type
+{
+};
+
+template <typename TargetAsyncResult>
+struct executor_binder_async_result_return_type<
+  TargetAsyncResult,
+  typename void_type<
+    typename TargetAsyncResult::return_type
+  >::type>
+{
+  typedef typename TargetAsyncResult::return_type return_type;
+};
+
+} // namespace detail
+
+template <typename T, typename Executor, typename Signature>
+class async_result<executor_binder<T, Executor>, Signature> :
+  public detail::executor_binder_completion_handler_async_result<
+    async_result<T, Signature>, Executor>,
+  public detail::executor_binder_async_result_return_type<
+    async_result<T, Signature> >
+{
+public:
   explicit async_result(executor_binder<T, Executor>& b)
-    : target_(b.get())
+    : detail::executor_binder_completion_handler_async_result<
+        async_result<T, Signature>, Executor>(b.get())
   {
   }
 
-  return_type get()
+  template <typename Initiation>
+  struct init_wrapper
   {
-    return target_.get();
+    template <typename Init>
+    init_wrapper(const Executor& ex, BOOST_ASIO_MOVE_ARG(Init) init)
+      : ex_(ex),
+        initiation_(BOOST_ASIO_MOVE_CAST(Init)(init))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          executor_binder<typename decay<Handler>::type, Executor>(
+            executor_arg_t(), ex_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args) const
+    {
+      initiation_(
+          executor_binder<typename decay<Handler>::type, Executor>(
+            executor_arg_t(), ex_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          executor_binder<typename decay<Handler>::type, Executor>(
+            executor_arg_t(), ex_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+    template <typename Handler>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler) const
+    {
+      initiation_(
+          executor_binder<typename decay<Handler>::type, Executor>(
+            executor_arg_t(), ex_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+    }
+
+#define BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF(n) \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+    { \
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)( \
+          executor_binder<typename decay<Handler>::type, Executor>( \
+            executor_arg_t(), ex_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    \
+    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+    void operator()( \
+        BOOST_ASIO_MOVE_ARG(Handler) handler, \
+        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
+    { \
+      initiation_( \
+          executor_binder<typename decay<Handler>::type, Executor>( \
+            executor_arg_t(), ex_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    } \
+    /**/
+    BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF)
+#undef BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+    Executor ex_;
+    Initiation initiation_;
+  };
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get(),
+        declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_executor(), BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get(), BOOST_ASIO_MOVE_CAST(Args)(args)...);
   }
 
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  template <typename Initiation, typename RawCompletionToken>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
+    (async_initiate<T, Signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<RawCompletionToken>().get())))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token)
+  {
+    return async_initiate<T, Signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          token.get_executor(), BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.get());
+  }
+
+#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
+  template <typename Initiation, typename RawCompletionToken, \
+      BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, \
+    (async_initiate<T, Signature>( \
+        declval<init_wrapper<typename decay<Initiation>::type> >(), \
+        declval<RawCompletionToken>().get(), \
+        BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n)))) \
+  initiate( \
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token, \
+      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    return async_initiate<T, Signature>( \
+        init_wrapper<typename decay<Initiation>::type>( \
+          token.get_executor(), BOOST_ASIO_MOVE_CAST(Initiation)(initiation)), \
+        token.get(), 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:
   async_result(const async_result&) BOOST_ASIO_DELETED;
   async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
-
-  async_result<T, Signature> target_;
 };
 
-template <typename T, typename Executor, typename Allocator>
-struct associated_allocator<executor_binder<T, Executor>, Allocator>
+template <template <typename, typename> class Associator,
+    typename T, typename Executor, typename DefaultCandidate>
+struct associator<Associator, executor_binder<T, Executor>, DefaultCandidate>
 {
-  typedef typename associated_allocator<T, Allocator>::type type;
+  typedef typename Associator<T, DefaultCandidate>::type type;
 
   static type get(const executor_binder<T, Executor>& b,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<T, Allocator>::get(b.get(), a);
+    return Associator<T, DefaultCandidate>::get(b.get(), c);
   }
 };
 
diff --git a/boost/asio/buffer.hpp b/boost/asio/buffer.hpp
index 409a668909279c0da277935f4019a85df69145f8..c849cc6adce193bef6ac220c4b669d892ec50cbd 100644
--- a/boost/asio/buffer.hpp
+++ b/boost/asio/buffer.hpp
@@ -2,7 +2,7 @@
 // buffer.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -907,7 +907,7 @@ private:
 /**
  * @returns <tt>mutable_buffer(b)</tt>.
  */
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
     const mutable_buffer& b) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(b);
@@ -920,7 +920,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  *     b.data(),
  *     min(b.size(), max_size_in_bytes)); @endcode
  */
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(const mutable_buffer& b,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    const mutable_buffer& b,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(
@@ -937,7 +938,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(const mutable_buffer& b,
 /**
  * @returns <tt>const_buffer(b)</tt>.
  */
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const const_buffer& b) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(b);
@@ -950,7 +951,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     b.data(),
  *     min(b.size(), max_size_in_bytes)); @endcode
  */
-inline BOOST_ASIO_CONST_BUFFER buffer(const const_buffer& b,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const const_buffer& b,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(b.data(),
@@ -966,8 +968,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(const const_buffer& b,
 /**
  * @returns <tt>mutable_buffer(data, size_in_bytes)</tt>.
  */
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(void* data,
-    std::size_t size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    void* data, std::size_t size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data, size_in_bytes);
 }
@@ -976,8 +978,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(void* data,
 /**
  * @returns <tt>const_buffer(data, size_in_bytes)</tt>.
  */
-inline BOOST_ASIO_CONST_BUFFER buffer(const void* data,
-    std::size_t size_in_bytes) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const void* data, std::size_t size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data, size_in_bytes);
 }
@@ -990,7 +992,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(const void* data,
  *     N * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N]) BOOST_ASIO_NOEXCEPT
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    PodType (&data)[N]) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data, N * sizeof(PodType));
 }
@@ -1003,7 +1006,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N]) BOOST_ASIO_NOEXCEPT
  *     min(N * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N],
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    PodType (&data)[N],
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data,
@@ -1019,7 +1023,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(PodType (&data)[N],
  *     N * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const PodType (&data)[N]) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data, N * sizeof(PodType));
@@ -1033,7 +1037,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(N * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(const PodType (&data)[N],
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const PodType (&data)[N],
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data,
@@ -1083,7 +1088,8 @@ struct buffer_types
 } // namespace detail
 
 template <typename PodType, std::size_t N>
-inline typename detail::buffer_types<PodType>::container_type
+BOOST_ASIO_NODISCARD inline
+typename detail::buffer_types<PodType>::container_type
 buffer(boost::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   typedef typename boost::asio::detail::buffer_types<PodType>::buffer_type
@@ -1095,7 +1101,8 @@ buffer(boost::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
 }
 
 template <typename PodType, std::size_t N>
-inline typename detail::buffer_types<PodType>::container_type
+BOOST_ASIO_NODISCARD inline
+typename detail::buffer_types<PodType>::container_type
 buffer(boost::array<PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
@@ -1119,7 +1126,7 @@ buffer(boost::array<PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
     boost::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(
@@ -1134,7 +1141,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(boost::array<PodType, N>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    boost::array<PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.c_array(),
@@ -1150,7 +1158,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(boost::array<PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     boost::array<const PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
@@ -1164,7 +1172,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(boost::array<const PodType, N>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    boost::array<const PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(),
@@ -1182,7 +1191,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(boost::array<const PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const boost::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
@@ -1196,7 +1205,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(const boost::array<PodType, N>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const boost::array<PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(),
@@ -1214,7 +1224,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(const boost::array<PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
     std::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.data(), data.size() * sizeof(PodType));
@@ -1228,7 +1238,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(std::array<PodType, N>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    std::array<PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.data(),
@@ -1244,7 +1255,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(std::array<PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     std::array<const PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
@@ -1258,7 +1269,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(std::array<const PodType, N>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    std::array<const PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(),
@@ -1274,7 +1286,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(std::array<const PodType, N>& data,
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const std::array<PodType, N>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
@@ -1288,7 +1300,8 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
-inline BOOST_ASIO_CONST_BUFFER buffer(const std::array<PodType, N>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
+    const std::array<PodType, N>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(),
@@ -1309,7 +1322,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(const std::array<PodType, N>& data,
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
     std::vector<PodType, Allocator>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(
@@ -1333,7 +1346,8 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(std::vector<PodType, Allocator>& data,
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+    std::vector<PodType, Allocator>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
@@ -1358,7 +1372,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(std::vector<PodType, Allocator>& data,
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const std::vector<PodType, Allocator>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(
@@ -1382,7 +1396,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const std::vector<PodType, Allocator>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
@@ -1406,7 +1420,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  * given string object.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
     std::basic_string<Elem, Traits, Allocator>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
@@ -1430,7 +1444,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  * given string object.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline BOOST_ASIO_MUTABLE_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_MUTABLE_BUFFER buffer(
     std::basic_string<Elem, Traits, Allocator>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
@@ -1453,7 +1467,7 @@ inline BOOST_ASIO_MUTABLE_BUFFER buffer(
  * given string object.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const std::basic_string<Elem, Traits, Allocator>& data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(Elem)
@@ -1476,7 +1490,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  * given string object.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     const std::basic_string<Elem, Traits, Allocator>& data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
@@ -1500,7 +1514,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  * data.size() * sizeof(Elem))</tt>.
  */
 template <typename Elem, typename Traits>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     basic_string_view<Elem, Traits> data) BOOST_ASIO_NOEXCEPT
 {
   return BOOST_ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
@@ -1521,7 +1535,7 @@ inline BOOST_ASIO_CONST_BUFFER buffer(
  *     min(data.size() * sizeof(Elem), max_size_in_bytes)); @endcode
  */
 template <typename Elem, typename Traits>
-inline BOOST_ASIO_CONST_BUFFER buffer(
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONST_BUFFER buffer(
     basic_string_view<Elem, Traits> data,
     std::size_t max_size_in_bytes) BOOST_ASIO_NOEXCEPT
 {
@@ -2097,7 +2111,8 @@ private:
  * @returns <tt>dynamic_string_buffer<Elem, Traits, Allocator>(data)</tt>.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
+BOOST_ASIO_NODISCARD inline
+dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
     std::basic_string<Elem, Traits, Allocator>& data) BOOST_ASIO_NOEXCEPT
 {
   return dynamic_string_buffer<Elem, Traits, Allocator>(data);
@@ -2109,7 +2124,8 @@ inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
  * max_size)</tt>.
  */
 template <typename Elem, typename Traits, typename Allocator>
-inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
+BOOST_ASIO_NODISCARD inline
+dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
     std::basic_string<Elem, Traits, Allocator>& data,
     std::size_t max_size) BOOST_ASIO_NOEXCEPT
 {
@@ -2121,7 +2137,8 @@ inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
  * @returns <tt>dynamic_vector_buffer<Elem, Allocator>(data)</tt>.
  */
 template <typename Elem, typename Allocator>
-inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
+BOOST_ASIO_NODISCARD inline
+dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
     std::vector<Elem, Allocator>& data) BOOST_ASIO_NOEXCEPT
 {
   return dynamic_vector_buffer<Elem, Allocator>(data);
@@ -2132,7 +2149,8 @@ inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
  * @returns <tt>dynamic_vector_buffer<Elem, Allocator>(data, max_size)</tt>.
  */
 template <typename Elem, typename Allocator>
-inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
+BOOST_ASIO_NODISCARD inline
+dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
     std::vector<Elem, Allocator>& data,
     std::size_t max_size) BOOST_ASIO_NOEXCEPT
 {
diff --git a/boost/asio/buffer_registration.hpp b/boost/asio/buffer_registration.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b05eb276654cde4d5f4fe5045e7a1707cd69f730
--- /dev/null
+++ b/boost/asio/buffer_registration.hpp
@@ -0,0 +1,330 @@
+//
+// buffer_registration.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BUFFER_REGISTRATION_HPP
+#define BOOST_ASIO_BUFFER_REGISTRATION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <iterator>
+#include <vector>
+#include <boost/asio/detail/memory.hpp>
+#include <boost/asio/execution/context.hpp>
+#include <boost/asio/execution/executor.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/is_executor.hpp>
+#include <boost/asio/query.hpp>
+#include <boost/asio/registered_buffer.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+# include <boost/asio/detail/scheduler.hpp>
+# include <boost/asio/detail/io_uring_service.hpp>
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class buffer_registration_base
+{
+protected:
+  static mutable_registered_buffer make_buffer(const mutable_buffer& b,
+      const void* scope, int index) BOOST_ASIO_NOEXCEPT
+  {
+    return mutable_registered_buffer(b, registered_buffer_id(scope, index));
+  }
+};
+
+} // namespace detail
+
+/// Automatically registers and unregistered buffers with an execution context.
+/**
+ * For portability, applications should assume that only one registration is
+ * permitted per execution context.
+ */
+template <typename MutableBufferSequence,
+    typename Allocator = std::allocator<void> >
+class buffer_registration
+  : detail::buffer_registration_base
+{
+public:
+  /// The allocator type used for allocating storage for the buffers container.
+  typedef Allocator allocator_type;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// The type of an iterator over the registered buffers.
+  typedef unspecified iterator;
+
+  /// The type of a const iterator over the registered buffers.
+  typedef unspecified const_iterator;
+#else // defined(GENERATING_DOCUMENTATION)
+  typedef std::vector<mutable_registered_buffer>::const_iterator iterator;
+  typedef std::vector<mutable_registered_buffer>::const_iterator const_iterator;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Register buffers with an executor's execution context.
+  template <typename Executor>
+  buffer_registration(const Executor& ex,
+      const MutableBufferSequence& buffer_sequence,
+      const allocator_type& alloc = allocator_type(),
+      typename constraint<
+        is_executor<Executor>::value || execution::is_executor<Executor>::value
+      >::type = 0)
+    : buffer_sequence_(buffer_sequence),
+      buffers_(
+          BOOST_ASIO_REBIND_ALLOC(allocator_type,
+            mutable_registered_buffer)(alloc))
+  {
+    init_buffers(buffer_registration::get_context(ex),
+        boost::asio::buffer_sequence_begin(buffer_sequence_),
+        boost::asio::buffer_sequence_end(buffer_sequence_));
+  }
+
+  /// Register buffers with an execution context.
+  template <typename ExecutionContext>
+  buffer_registration(ExecutionContext& ctx,
+      const MutableBufferSequence& buffer_sequence,
+      const allocator_type& alloc = allocator_type(),
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value
+      >::type = 0)
+    : buffer_sequence_(buffer_sequence),
+      buffers_(
+          BOOST_ASIO_REBIND_ALLOC(allocator_type,
+            mutable_registered_buffer)(alloc))
+  {
+    init_buffers(ctx,
+        boost::asio::buffer_sequence_begin(buffer_sequence_),
+        boost::asio::buffer_sequence_end(buffer_sequence_));
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move constructor.
+  buffer_registration(buffer_registration&& other) BOOST_ASIO_NOEXCEPT
+    : buffer_sequence_(std::move(other.buffer_sequence_)),
+      buffers_(std::move(other.buffers_))
+  {
+#if defined(BOOST_ASIO_HAS_IO_URING)
+    service_ = other.service_;
+    other.service_ = 0;
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Unregisters the buffers.
+  ~buffer_registration()
+  {
+#if defined(BOOST_ASIO_HAS_IO_URING)
+    if (service_)
+      service_->unregister_buffers();
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+  }
+  
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move assignment.
+  buffer_registration& operator=(
+      buffer_registration&& other) BOOST_ASIO_NOEXCEPT
+  {
+    if (this != &other)
+    {
+      buffer_sequence_ = std::move(other.buffer_sequence_);
+      buffers_ = std::move(other.buffers_);
+#if defined(BOOST_ASIO_HAS_IO_URING)
+      if (service_)
+        service_->unregister_buffers();
+      service_ = other.service_;
+      other.service_ = 0;
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+    }
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Get the number of registered buffers.
+  std::size_t size() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_.size();
+  }
+
+  /// Get the begin iterator for the sequence of registered buffers.
+  const_iterator begin() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_.begin();
+  }
+
+  /// Get the begin iterator for the sequence of registered buffers.
+  const_iterator cbegin() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_.cbegin();
+  }
+
+  /// Get the end iterator for the sequence of registered buffers.
+  const_iterator end() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_.end();
+  }
+
+  /// Get the end iterator for the sequence of registered buffers.
+  const_iterator cend() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_.cend();
+  }
+
+  /// Get the buffer at the specified index.
+  const mutable_registered_buffer& operator[](std::size_t i) BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_[i];
+  }
+
+  /// Get the buffer at the specified index.
+  const mutable_registered_buffer& at(std::size_t i) BOOST_ASIO_NOEXCEPT
+  {
+    return buffers_.at(i);
+  }
+
+private:
+  // Disallow copying and assignment.
+  buffer_registration(const buffer_registration&) BOOST_ASIO_DELETED;
+  buffer_registration& operator=(const buffer_registration&) BOOST_ASIO_DELETED;
+
+  // Helper function to get an executor's context.
+  template <typename T>
+  static execution_context& get_context(const T& t,
+      typename enable_if<execution::is_executor<T>::value>::type* = 0)
+  {
+    return boost::asio::query(t, execution::context);
+  }
+
+  // Helper function to get an executor's context.
+  template <typename T>
+  static execution_context& get_context(const T& t,
+      typename enable_if<!execution::is_executor<T>::value>::type* = 0)
+  {
+    return t.context();
+  }
+
+  // Helper function to initialise the container of buffers.
+  template <typename Iterator>
+  void init_buffers(execution_context& ctx, Iterator begin, Iterator end)
+  {
+    std::size_t n = std::distance(begin, end);
+    buffers_.resize(n);
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+    service_ = &use_service<detail::io_uring_service>(ctx);
+    std::vector<iovec,
+      BOOST_ASIO_REBIND_ALLOC(allocator_type, iovec)> iovecs(n,
+          BOOST_ASIO_REBIND_ALLOC(allocator_type, iovec)(
+            buffers_.get_allocator()));
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+    Iterator iter = begin;
+    for (int index = 0; iter != end; ++index, ++iter)
+    {
+      mutable_buffer b(*iter);
+      std::size_t i = static_cast<std::size_t>(index);
+      buffers_[i] = this->make_buffer(b, &ctx, index);
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+      iovecs[i].iov_base = buffers_[i].data();
+      iovecs[i].iov_len = buffers_[i].size();
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+    }
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+    if (n > 0)
+    {
+      service_->register_buffers(&iovecs[0],
+          static_cast<unsigned>(iovecs.size()));
+    }
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+  }
+
+  MutableBufferSequence buffer_sequence_;
+  std::vector<mutable_registered_buffer,
+    BOOST_ASIO_REBIND_ALLOC(allocator_type,
+      mutable_registered_buffer)> buffers_;
+#if defined(BOOST_ASIO_HAS_IO_URING)
+  detail::io_uring_service* service_;
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+};
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+/// Register buffers with an execution context.
+template <typename Executor, typename MutableBufferSequence>
+BOOST_ASIO_NODISCARD inline
+buffer_registration<MutableBufferSequence>
+register_buffers(const Executor& ex,
+    const MutableBufferSequence& buffer_sequence,
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type = 0)
+{
+  return buffer_registration<MutableBufferSequence>(ex, buffer_sequence);
+}
+
+/// Register buffers with an execution context.
+template <typename Executor, typename MutableBufferSequence, typename Allocator>
+BOOST_ASIO_NODISCARD inline
+buffer_registration<MutableBufferSequence, Allocator>
+register_buffers(const Executor& ex,
+    const MutableBufferSequence& buffer_sequence, const Allocator& alloc,
+    typename constraint<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type = 0)
+{
+  return buffer_registration<MutableBufferSequence, Allocator>(
+      ex, buffer_sequence, alloc);
+}
+
+/// Register buffers with an execution context.
+template <typename ExecutionContext, typename MutableBufferSequence>
+BOOST_ASIO_NODISCARD inline
+buffer_registration<MutableBufferSequence>
+register_buffers(ExecutionContext& ctx,
+    const MutableBufferSequence& buffer_sequence,
+    typename constraint<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    >::type = 0)
+{
+  return buffer_registration<MutableBufferSequence>(ctx, buffer_sequence);
+}
+
+/// Register buffers with an execution context.
+template <typename ExecutionContext,
+    typename MutableBufferSequence, typename Allocator>
+BOOST_ASIO_NODISCARD inline
+buffer_registration<MutableBufferSequence, Allocator>
+register_buffers(ExecutionContext& ctx,
+    const MutableBufferSequence& buffer_sequence, const Allocator& alloc,
+    typename constraint<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    >::type = 0)
+{
+  return buffer_registration<MutableBufferSequence, Allocator>(
+      ctx, buffer_sequence, alloc);
+}
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BUFFER_REGISTRATION_HPP
diff --git a/boost/asio/buffered_read_stream.hpp b/boost/asio/buffered_read_stream.hpp
index 85ff59cc005169cdc52031251d65941e33b49bc4..eff545f634a36b825b1fe6156dcf143ce4fcd35e 100644
--- a/boost/asio/buffered_read_stream.hpp
+++ b/boost/asio/buffered_read_stream.hpp
@@ -2,7 +2,7 @@
 // buffered_read_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -137,6 +137,10 @@ public:
 
   /// Start an asynchronous write. The data being written must be valid for the
   /// lifetime of the asynchronous operation.
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) WriteHandler
@@ -160,6 +164,10 @@ public:
   std::size_t fill(boost::system::error_code& ec);
 
   /// Start an asynchronous fill.
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) ReadHandler
@@ -183,6 +191,10 @@ public:
 
   /// Start an asynchronous read. The buffer into which the data will be read
   /// must be valid for the lifetime of the asynchronous operation.
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) ReadHandler
diff --git a/boost/asio/buffered_read_stream_fwd.hpp b/boost/asio/buffered_read_stream_fwd.hpp
index cf6eb77b25bc5306f964256dda0b10435a82bf28..c8b08a62bbbac44c8d54e6a664940be4a86b6f0d 100644
--- a/boost/asio/buffered_read_stream_fwd.hpp
+++ b/boost/asio/buffered_read_stream_fwd.hpp
@@ -2,7 +2,7 @@
 // buffered_read_stream_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/buffered_stream.hpp b/boost/asio/buffered_stream.hpp
index b89a5fdabc23d196bb419c02c9303df2e0cdb673..39b6cfce19724f2e464d527d99b71a5521ef7e1f 100644
--- a/boost/asio/buffered_stream.hpp
+++ b/boost/asio/buffered_stream.hpp
@@ -2,7 +2,7 @@
 // buffered_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -126,6 +126,10 @@ public:
   }
 
   /// Start an asynchronous flush.
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) WriteHandler
@@ -159,6 +163,10 @@ public:
 
   /// Start an asynchronous write. The data being written must be valid for the
   /// lifetime of the asynchronous operation.
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) WriteHandler
@@ -188,6 +196,10 @@ public:
   }
 
   /// Start an asynchronous fill.
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) ReadHandler
@@ -220,6 +232,10 @@ public:
 
   /// Start an asynchronous read. The buffer into which the data will be read
   /// must be valid for the lifetime of the asynchronous operation.
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) ReadHandler
diff --git a/boost/asio/buffered_stream_fwd.hpp b/boost/asio/buffered_stream_fwd.hpp
index c72ce1f533303224d58ceef8950d25dedff5e4e6..ac9e3283db2d0ddd18beb971224a451d2fd65ef1 100644
--- a/boost/asio/buffered_stream_fwd.hpp
+++ b/boost/asio/buffered_stream_fwd.hpp
@@ -2,7 +2,7 @@
 // buffered_stream_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/buffered_write_stream.hpp b/boost/asio/buffered_write_stream.hpp
index 2571a1f88578f8d776c229eac2d3265b889db004..d619ae534c33bb7c3a7ea917a80a5f25c03b5ce4 100644
--- a/boost/asio/buffered_write_stream.hpp
+++ b/boost/asio/buffered_write_stream.hpp
@@ -2,7 +2,7 @@
 // buffered_write_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -129,6 +129,10 @@ public:
   std::size_t flush(boost::system::error_code& ec);
 
   /// Start an asynchronous flush.
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) WriteHandler
@@ -152,6 +156,10 @@ public:
 
   /// Start an asynchronous write. The data being written must be valid for the
   /// lifetime of the asynchronous operation.
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) WriteHandler
@@ -181,6 +189,10 @@ public:
 
   /// Start an asynchronous read. The buffer into which the data will be read
   /// must be valid for the lifetime of the asynchronous operation.
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) ReadHandler
diff --git a/boost/asio/buffered_write_stream_fwd.hpp b/boost/asio/buffered_write_stream_fwd.hpp
index 22ee54ed972a21050f28f88987ca36cf33de8228..4d2f4b9b59f4be5f9481808ee6b6a058878746a4 100644
--- a/boost/asio/buffered_write_stream_fwd.hpp
+++ b/boost/asio/buffered_write_stream_fwd.hpp
@@ -2,7 +2,7 @@
 // buffered_write_stream_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/buffers_iterator.hpp b/boost/asio/buffers_iterator.hpp
index c53c5fc3e4610bdbe66577750e048bda4ed025fb..1bff44e64915d010154b957d54c85864aab42f1e 100644
--- a/boost/asio/buffers_iterator.hpp
+++ b/boost/asio/buffers_iterator.hpp
@@ -2,7 +2,7 @@
 // buffers_iterator.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/cancellation_signal.hpp b/boost/asio/cancellation_signal.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..6a8d644be3c5429514dd426fd97069aa57e12d96
--- /dev/null
+++ b/boost/asio/cancellation_signal.hpp
@@ -0,0 +1,307 @@
+//
+// cancellation_signal.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_CANCELLATION_SIGNAL_HPP
+#define BOOST_ASIO_CANCELLATION_SIGNAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <cassert>
+#include <new>
+#include <utility>
+#include <boost/asio/cancellation_type.hpp>
+#include <boost/asio/detail/cstddef.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 {
+namespace detail {
+
+class cancellation_handler_base
+{
+public:
+  virtual void call(cancellation_type_t) = 0;
+  virtual std::pair<void*, std::size_t> destroy() BOOST_ASIO_NOEXCEPT = 0;
+
+protected:
+  ~cancellation_handler_base() {}
+};
+
+template <typename Handler>
+class cancellation_handler
+  : public cancellation_handler_base
+{
+public:
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+  template <typename... Args>
+  cancellation_handler(std::size_t size, BOOST_ASIO_MOVE_ARG(Args)... args)
+    : handler_(BOOST_ASIO_MOVE_CAST(Args)(args)...),
+      size_(size)
+  {
+  }
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+  cancellation_handler(std::size_t size)
+    : handler_(),
+      size_(size)
+  {
+  }
+
+#define BOOST_ASIO_PRIVATE_HANDLER_CTOR_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  cancellation_handler(std::size_t size, BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+    : handler_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)), \
+      size_(size) \
+  { \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_HANDLER_CTOR_DEF)
+#undef BOOST_ASIO_PRIVATE_HANDLER_CTOR_DEF
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  void call(cancellation_type_t type)
+  {
+    handler_(type);
+  }
+
+  std::pair<void*, std::size_t> destroy() BOOST_ASIO_NOEXCEPT
+  {
+    std::pair<void*, std::size_t> mem(this, size_);
+    this->cancellation_handler::~cancellation_handler();
+    return mem;
+  }
+
+  Handler& handler() BOOST_ASIO_NOEXCEPT
+  {
+    return handler_;
+  }
+
+private:
+  ~cancellation_handler()
+  {
+  }
+
+  Handler handler_;
+  std::size_t size_;
+};
+
+} // namespace detail
+
+class cancellation_slot;
+
+/// A cancellation signal with a single slot.
+class cancellation_signal
+{
+public:
+  BOOST_ASIO_CONSTEXPR cancellation_signal()
+    : handler_(0)
+  {
+  }
+
+  BOOST_ASIO_DECL ~cancellation_signal();
+
+  /// Emits the signal and causes invocation of the slot's handler, if any.
+  void emit(cancellation_type_t type)
+  {
+    if (handler_)
+      handler_->call(type);
+  }
+
+  /// Returns the single slot associated with the signal.
+  /**
+   * The signal object must remain valid for as long the slot may be used.
+   * Destruction of the signal invalidates the slot.
+   */
+  cancellation_slot slot() BOOST_ASIO_NOEXCEPT;
+
+private:
+  cancellation_signal(const cancellation_signal&) BOOST_ASIO_DELETED;
+  cancellation_signal& operator=(const cancellation_signal&) BOOST_ASIO_DELETED;
+
+  detail::cancellation_handler_base* handler_;
+};
+
+/// A slot associated with a cancellation signal.
+class cancellation_slot
+{
+public:
+  /// Creates a slot that is not connected to any cancellation signal.
+  BOOST_ASIO_CONSTEXPR cancellation_slot()
+    : handler_(0)
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) \
+  || defined(GENERATING_DOCUMENTATION)
+  /// Installs a handler into the slot, constructing the new object directly.
+  /**
+   * Destroys any existing handler in the slot, then installs the new handler,
+   * constructing it with the supplied @c args.
+   *
+   * The handler is a function object to be called when the signal is emitted.
+   * The signature of the handler must be
+   * @code void handler(boost::asio::cancellation_type_t); @endcode
+   *
+   * @param args Arguments to be passed to the @c CancellationHandler object's
+   * constructor.
+   *
+   * @returns A reference to the newly installed handler.
+   *
+   * @note Handlers installed into the slot via @c emplace are not required to
+   * be copy constructible or move constructible.
+   */
+  template <typename CancellationHandler, typename... Args>
+  CancellationHandler& emplace(BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    typedef detail::cancellation_handler<CancellationHandler>
+      cancellation_handler_type;
+    auto_delete_helper del = { prepare_memory(
+        sizeof(cancellation_handler_type),
+        BOOST_ASIO_ALIGNOF(CancellationHandler)) };
+    cancellation_handler_type* handler_obj =
+      new (del.mem.first) cancellation_handler_type(
+        del.mem.second, BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    del.mem.first = 0;
+    *handler_ = handler_obj;
+    return handler_obj->handler();
+  }
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+      //   || defined(GENERATING_DOCUMENTATION)
+  template <typename CancellationHandler>
+  CancellationHandler& emplace()
+  {
+    typedef detail::cancellation_handler<CancellationHandler>
+      cancellation_handler_type;
+    auto_delete_helper del = { prepare_memory(
+        sizeof(cancellation_handler_type),
+        BOOST_ASIO_ALIGNOF(CancellationHandler)) };
+    cancellation_handler_type* handler_obj =
+      new (del.mem.first) cancellation_handler_type(del.mem.second);
+    del.mem.first = 0;
+    *handler_ = handler_obj;
+    return handler_obj->handler();
+  }
+
+#define BOOST_ASIO_PRIVATE_HANDLER_EMPLACE_DEF(n) \
+  template <typename CancellationHandler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  CancellationHandler& emplace(BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
+  { \
+    typedef detail::cancellation_handler<CancellationHandler> \
+      cancellation_handler_type; \
+    auto_delete_helper del = { prepare_memory( \
+        sizeof(cancellation_handler_type), \
+        BOOST_ASIO_ALIGNOF(CancellationHandler)) }; \
+    cancellation_handler_type* handler_obj = \
+      new (del.mem.first) cancellation_handler_type( \
+        del.mem.second, BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    del.mem.first = 0; \
+    *handler_ = handler_obj; \
+    return handler_obj->handler(); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_HANDLER_EMPLACE_DEF)
+#undef BOOST_ASIO_PRIVATE_HANDLER_EMPLACE_DEF
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+  /// Installs a handler into the slot.
+  /**
+   * Destroys any existing handler in the slot, then installs the new handler,
+   * constructing it as a decay-copy of the supplied handler.
+   *
+   * The handler is a function object to be called when the signal is emitted.
+   * The signature of the handler must be
+   * @code void handler(boost::asio::cancellation_type_t); @endcode
+   *
+   * @param handler The handler to be installed.
+   *
+   * @returns A reference to the newly installed handler.
+   */
+  template <typename CancellationHandler>
+  typename decay<CancellationHandler>::type& assign(
+      BOOST_ASIO_MOVE_ARG(CancellationHandler) handler)
+  {
+    return this->emplace<typename decay<CancellationHandler>::type>(
+        BOOST_ASIO_MOVE_CAST(CancellationHandler)(handler));
+  }
+
+  /// Clears the slot.
+  /**
+   * Destroys any existing handler in the slot.
+   */
+  BOOST_ASIO_DECL void clear();
+
+  /// Returns whether the slot is connected to a signal.
+  BOOST_ASIO_CONSTEXPR bool is_connected() const BOOST_ASIO_NOEXCEPT
+  {
+    return handler_ != 0;
+  }
+
+  /// Returns whether the slot is connected and has an installed handler.
+  BOOST_ASIO_CONSTEXPR bool has_handler() const BOOST_ASIO_NOEXCEPT
+  {
+    return handler_ != 0 && *handler_ != 0;
+  }
+
+  /// Compare two slots for equality.
+  friend BOOST_ASIO_CONSTEXPR bool operator==(const cancellation_slot& lhs,
+      const cancellation_slot& rhs) BOOST_ASIO_NOEXCEPT
+  {
+    return lhs.handler_ == rhs.handler_;
+  }
+
+  /// Compare two slots for inequality.
+  friend BOOST_ASIO_CONSTEXPR bool operator!=(const cancellation_slot& lhs,
+      const cancellation_slot& rhs) BOOST_ASIO_NOEXCEPT
+  {
+    return lhs.handler_ != rhs.handler_;
+  }
+
+private:
+  friend class cancellation_signal;
+
+  BOOST_ASIO_CONSTEXPR cancellation_slot(int,
+      detail::cancellation_handler_base** handler)
+    : handler_(handler)
+  {
+  }
+
+  BOOST_ASIO_DECL std::pair<void*, std::size_t> prepare_memory(
+      std::size_t size, std::size_t align);
+
+  struct auto_delete_helper
+  {
+    std::pair<void*, std::size_t> mem;
+
+    BOOST_ASIO_DECL ~auto_delete_helper();
+  };
+
+  detail::cancellation_handler_base** handler_;
+};
+
+inline cancellation_slot cancellation_signal::slot() BOOST_ASIO_NOEXCEPT
+{
+  return cancellation_slot(0, &handler_);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/impl/cancellation_signal.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // BOOST_ASIO_CANCELLATION_SIGNAL_HPP
diff --git a/boost/asio/cancellation_state.hpp b/boost/asio/cancellation_state.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..156b420a03763e14f608bde7b904fc15d30afdf9
--- /dev/null
+++ b/boost/asio/cancellation_state.hpp
@@ -0,0 +1,237 @@
+//
+// cancellation_state.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_CANCELLATION_STATE_HPP
+#define BOOST_ASIO_CANCELLATION_STATE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <cassert>
+#include <new>
+#include <utility>
+#include <boost/asio/cancellation_signal.hpp>
+#include <boost/asio/detail/cstddef.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// A simple cancellation signal propagation filter.
+template <cancellation_type_t Mask>
+struct cancellation_filter
+{
+  /// Returns <tt>type & Mask</tt>.
+  cancellation_type_t operator()(
+      cancellation_type_t type) const BOOST_ASIO_NOEXCEPT
+  {
+    return type & Mask;
+  }
+};
+
+/// A cancellation filter that disables cancellation.
+typedef cancellation_filter<cancellation_type::none>
+  disable_cancellation;
+
+/// A cancellation filter that enables terminal cancellation only.
+typedef cancellation_filter<cancellation_type::terminal>
+  enable_terminal_cancellation;
+
+#if defined(GENERATING_DOCUMENTATION)
+
+/// A cancellation filter that enables terminal and partial cancellation.
+typedef cancellation_filter<
+    cancellation_type::terminal | cancellation_type::partial>
+  enable_partial_cancellation;
+
+/// A cancellation filter that enables terminal, partial and total cancellation.
+typedef cancellation_filter<cancellation_type::terminal
+    | cancellation_type::partial | cancellation_type::total>
+  enable_total_cancellation;
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+typedef cancellation_filter<
+    static_cast<cancellation_type_t>(
+      static_cast<unsigned int>(cancellation_type::terminal)
+        | static_cast<unsigned int>(cancellation_type::partial))>
+  enable_partial_cancellation;
+
+typedef cancellation_filter<
+    static_cast<cancellation_type_t>(
+      static_cast<unsigned int>(cancellation_type::terminal)
+        | static_cast<unsigned int>(cancellation_type::partial)
+        | static_cast<unsigned int>(cancellation_type::total))>
+  enable_total_cancellation;
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+/// A cancellation state is used for chaining signals and slots in compositions.
+class cancellation_state
+{
+public:
+  /// Construct a disconnected cancellation state.
+  BOOST_ASIO_CONSTEXPR cancellation_state() BOOST_ASIO_NOEXCEPT
+    : impl_(0)
+  {
+  }
+
+  /// Construct and attach to a parent slot to create a new child slot.
+  /**
+   * Initialises the cancellation state so that it allows terminal cancellation
+   * only. Equivalent to <tt>cancellation_state(slot,
+   * enable_terminal_cancellation())</tt>.
+   *
+   * @param slot The parent cancellation slot to which the state will be
+   * attached.
+   */
+  template <typename CancellationSlot>
+  BOOST_ASIO_CONSTEXPR explicit cancellation_state(CancellationSlot slot)
+    : impl_(slot.is_connected() ? &slot.template emplace<impl<> >() : 0)
+  {
+  }
+
+  /// Construct and attach to a parent slot to create a new child slot.
+  /**
+   * @param slot The parent cancellation slot to which the state will be
+   * attached.
+   *
+   * @param filter A function object that is used to transform incoming
+   * cancellation signals as they are received from the parent slot. This
+   * function object must have the signature:
+   * @code boost::asio::cancellation_type_t filter(
+   *     boost::asio::cancellation_type_t); @endcode
+   *
+   * The library provides the following pre-defined cancellation filters:
+   *
+   * @li boost::asio::disable_cancellation
+   * @li boost::asio::enable_terminal_cancellation
+   * @li boost::asio::enable_partial_cancellation
+   * @li boost::asio::enable_total_cancellation
+   */
+  template <typename CancellationSlot, typename Filter>
+  BOOST_ASIO_CONSTEXPR cancellation_state(CancellationSlot slot, Filter filter)
+    : impl_(slot.is_connected()
+        ? &slot.template emplace<impl<Filter, Filter> >(filter, filter)
+        : 0)
+  {
+  }
+
+  /// Construct and attach to a parent slot to create a new child slot.
+  /**
+   * @param slot The parent cancellation slot to which the state will be
+   * attached.
+   *
+   * @param in_filter A function object that is used to transform incoming
+   * cancellation signals as they are received from the parent slot. This
+   * function object must have the signature:
+   * @code boost::asio::cancellation_type_t in_filter(
+   *     boost::asio::cancellation_type_t); @endcode
+   *
+   * @param out_filter A function object that is used to transform outcoming
+   * cancellation signals as they are relayed to the child slot. This function
+   * object must have the signature:
+   * @code boost::asio::cancellation_type_t out_filter(
+   *     boost::asio::cancellation_type_t); @endcode
+   *
+   * The library provides the following pre-defined cancellation filters:
+   *
+   * @li boost::asio::disable_cancellation
+   * @li boost::asio::enable_terminal_cancellation
+   * @li boost::asio::enable_partial_cancellation
+   * @li boost::asio::enable_total_cancellation
+   */
+  template <typename CancellationSlot, typename InFilter, typename OutFilter>
+  BOOST_ASIO_CONSTEXPR cancellation_state(CancellationSlot slot,
+      InFilter in_filter, OutFilter out_filter)
+    : impl_(slot.is_connected()
+        ? &slot.template emplace<impl<InFilter, OutFilter> >(
+            BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
+            BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter))
+        : 0)
+  {
+  }
+
+  /// Returns the single child slot associated with the state.
+  /**
+   * This sub-slot is used with the operations that are being composed.
+   */
+  BOOST_ASIO_CONSTEXPR cancellation_slot slot() const BOOST_ASIO_NOEXCEPT
+  {
+    return impl_ ? impl_->signal_.slot() : cancellation_slot();
+  }
+
+  /// Returns the cancellation types that have been triggered.
+  cancellation_type_t cancelled() const BOOST_ASIO_NOEXCEPT
+  {
+    return impl_ ? impl_->cancelled_ : cancellation_type_t();
+  }
+
+  /// Clears the specified cancellation types, if they have been triggered.
+  void clear(cancellation_type_t mask = cancellation_type::all)
+    BOOST_ASIO_NOEXCEPT
+  {
+    if (impl_)
+      impl_->cancelled_ &= ~mask;
+  }
+
+private:
+  struct impl_base
+  {
+    impl_base()
+      : cancelled_()
+    {
+    }
+
+    cancellation_signal signal_;
+    cancellation_type_t cancelled_;
+  };
+
+  template <
+      typename InFilter = enable_terminal_cancellation,
+      typename OutFilter = InFilter>
+  struct impl : impl_base
+  {
+    impl()
+      : in_filter_(),
+        out_filter_()
+    {
+    }
+
+    impl(InFilter in_filter, OutFilter out_filter)
+      : in_filter_(BOOST_ASIO_MOVE_CAST(InFilter)(in_filter)),
+        out_filter_(BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter))
+    {
+    }
+
+    void operator()(cancellation_type_t in)
+    {
+      this->cancelled_ = in_filter_(in);
+      cancellation_type_t out = out_filter_(this->cancelled_);
+      if (out != cancellation_type::none)
+        this->signal_.emit(out);
+    }
+
+    InFilter in_filter_;
+    OutFilter out_filter_;
+  };
+
+  impl_base* impl_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_CANCELLATION_STATE_HPP
diff --git a/boost/asio/cancellation_type.hpp b/boost/asio/cancellation_type.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ef68883f031ae0aa7483864b1c7871dd8dc41bd4
--- /dev/null
+++ b/boost/asio/cancellation_type.hpp
@@ -0,0 +1,176 @@
+//
+// cancellation_type.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_CANCELLATION_TYPE_HPP
+#define BOOST_ASIO_CANCELLATION_TYPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+# if defined(GENERATING_DOCUMENTATION)
+
+/// Enumeration representing the different types of cancellation that may
+/// be requested from or implemented by an asynchronous operation.
+enum cancellation_type
+{
+  /// Bitmask representing no types of cancellation.
+  none = 0,
+
+  /// Requests cancellation where, following a successful cancellation, the only
+  /// safe operations on the I/O object are closure or destruction.
+  terminal = 1,
+
+  /// Requests cancellation where a successful cancellation may result in
+  /// partial side effects or no side effects. Following cancellation, the I/O
+  /// object is in a well-known state, and may be used for further operations.
+  partial = 2,
+
+  /// Requests cancellation where a successful cancellation results in no
+  /// apparent side effects. Following cancellation, the I/O object is in the
+  /// same observable state as it was prior to the operation.
+  total = 4,
+
+  /// Bitmask representing all types of cancellation.
+  all = 0xFFFFFFFF
+};
+
+/// Portability typedef.
+typedef cancellation_type cancellation_type_t;
+
+#elif defined(BOOST_ASIO_HAS_ENUM_CLASS)
+
+enum class cancellation_type : unsigned int
+{
+  none = 0,
+  terminal = 1,
+  partial = 2,
+  total = 4,
+  all = 0xFFFFFFFF
+};
+
+typedef cancellation_type cancellation_type_t;
+
+#else // defined(BOOST_ASIO_HAS_ENUM_CLASS)
+
+namespace cancellation_type {
+
+enum cancellation_type_t
+{
+  none = 0,
+  terminal = 1,
+  partial = 2,
+  total = 4,
+  all = 0xFFFFFFFF
+};
+
+} // namespace cancellation_type
+
+typedef cancellation_type::cancellation_type_t cancellation_type_t;
+
+#endif // defined(BOOST_ASIO_HAS_ENUM_CLASS)
+
+/// Negation operator.
+/**
+ * @relates cancellation_type
+ */
+inline BOOST_ASIO_CONSTEXPR bool operator!(cancellation_type_t x)
+{
+  return static_cast<unsigned int>(x) == 0;
+}
+
+/// Bitwise and operator.
+/**
+ * @relates cancellation_type
+ */
+inline BOOST_ASIO_CONSTEXPR cancellation_type_t operator&(
+    cancellation_type_t x, cancellation_type_t y)
+{
+  return static_cast<cancellation_type_t>(
+      static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
+}
+
+/// Bitwise or operator.
+/**
+ * @relates cancellation_type
+ */
+inline BOOST_ASIO_CONSTEXPR cancellation_type_t operator|(
+    cancellation_type_t x, cancellation_type_t y)
+{
+  return static_cast<cancellation_type_t>(
+      static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
+}
+
+/// Bitwise xor operator.
+/**
+ * @relates cancellation_type
+ */
+inline BOOST_ASIO_CONSTEXPR cancellation_type_t operator^(
+    cancellation_type_t x, cancellation_type_t y)
+{
+  return static_cast<cancellation_type_t>(
+      static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
+}
+
+/// Bitwise negation operator.
+/**
+ * @relates cancellation_type
+ */
+inline BOOST_ASIO_CONSTEXPR cancellation_type_t operator~(cancellation_type_t x)
+{
+  return static_cast<cancellation_type_t>(~static_cast<unsigned int>(x));
+}
+
+/// Bitwise and-assignment operator.
+/**
+ * @relates cancellation_type
+ */
+inline cancellation_type_t& operator&=(
+    cancellation_type_t& x, cancellation_type_t y)
+{
+  x = x & y;
+  return x;
+}
+
+/// Bitwise or-assignment operator.
+/**
+ * @relates cancellation_type
+ */
+inline cancellation_type_t& operator|=(
+    cancellation_type_t& x, cancellation_type_t y)
+{
+  x = x | y;
+  return x;
+}
+
+/// Bitwise xor-assignment operator.
+/**
+ * @relates cancellation_type
+ */
+inline cancellation_type_t& operator^=(
+    cancellation_type_t& x, cancellation_type_t y)
+{
+  x = x ^ y;
+  return x;
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_CANCELLATION_TYPE_HPP
diff --git a/boost/asio/co_spawn.hpp b/boost/asio/co_spawn.hpp
index d061c85763029111385cdc8ac1f16960fbc30a93..b453fc0ec7d3aae56aac9505c743003bcc614c46 100644
--- a/boost/asio/co_spawn.hpp
+++ b/boost/asio/co_spawn.hpp
@@ -2,7 +2,7 @@
 // co_spawn.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -55,11 +55,14 @@ struct awaitable_signature<awaitable<void, Executor>>
  * @param a The boost::asio::awaitable object that is the result of calling the
  * coroutine's entry point function.
  *
- * @param token The completion token that will handle the notification that
+ * @param token The @ref completion_token that will handle the notification that
  * the thread of execution has completed. The function signature of the
  * completion handler must be:
  * @code void handler(std::exception_ptr, T); @endcode
  *
+ * @par Completion Signature
+ * @code void(std::exception_ptr, T) @endcode
+ *
  * @par Example
  * @code
  * boost::asio::awaitable<std::size_t> echo(tcp::socket socket)
@@ -96,6 +99,11 @@ struct awaitable_signature<awaitable<void, Executor>>
  *     std::cout << "transferred " << n << "\n";
  *   });
  * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * The new thread of execution is created with a cancellation state that
+ * supports @c cancellation_type::terminal values only. To change the
+ * cancellation state, call boost::asio::this_coro::reset_cancellation_state.
  */
 template <typename Executor, typename T, typename AwaitableExecutor,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(
@@ -119,11 +127,14 @@ co_spawn(const Executor& ex, awaitable<T, AwaitableExecutor> a,
  * @param a The boost::asio::awaitable object that is the result of calling the
  * coroutine's entry point function.
  *
- * @param token The completion token that will handle the notification that
+ * @param token The @ref completion_token that will handle the notification that
  * the thread of execution has completed. The function signature of the
  * completion handler must be:
  * @code void handler(std::exception_ptr); @endcode
  *
+ * @par Completion Signature
+ * @code void(std::exception_ptr) @endcode
+ *
  * @par Example
  * @code
  * boost::asio::awaitable<void> echo(tcp::socket socket)
@@ -152,6 +163,11 @@ co_spawn(const Executor& ex, awaitable<T, AwaitableExecutor> a,
  *   echo(std::move(my_tcp_socket)),
  *   boost::asio::detached);
  * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * The new thread of execution is created with a cancellation state that
+ * supports @c cancellation_type::terminal values only. To change the
+ * cancellation state, call boost::asio::this_coro::reset_cancellation_state.
  */
 template <typename Executor, typename AwaitableExecutor,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(
@@ -175,11 +191,14 @@ co_spawn(const Executor& ex, awaitable<void, AwaitableExecutor> a,
  * @param a The boost::asio::awaitable object that is the result of calling the
  * coroutine's entry point function.
  *
- * @param token The completion token that will handle the notification that
+ * @param token The @ref completion_token that will handle the notification that
  * the thread of execution has completed. The function signature of the
  * completion handler must be:
  * @code void handler(std::exception_ptr); @endcode
  *
+ * @par Completion Signature
+ * @code void(std::exception_ptr, T) @endcode
+ *
  * @par Example
  * @code
  * boost::asio::awaitable<std::size_t> echo(tcp::socket socket)
@@ -216,6 +235,11 @@ co_spawn(const Executor& ex, awaitable<void, AwaitableExecutor> a,
  *     std::cout << "transferred " << n << "\n";
  *   });
  * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * The new thread of execution is created with a cancellation state that
+ * supports @c cancellation_type::terminal values only. To change the
+ * cancellation state, call boost::asio::this_coro::reset_cancellation_state.
  */
 template <typename ExecutionContext, typename T, typename AwaitableExecutor,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(
@@ -242,11 +266,14 @@ co_spawn(ExecutionContext& ctx, awaitable<T, AwaitableExecutor> a,
  * @param a The boost::asio::awaitable object that is the result of calling the
  * coroutine's entry point function.
  *
- * @param token The completion token that will handle the notification that
+ * @param token The @ref completion_token that will handle the notification that
  * the thread of execution has completed. The function signature of the
  * completion handler must be:
  * @code void handler(std::exception_ptr); @endcode
  *
+ * @par Completion Signature
+ * @code void(std::exception_ptr) @endcode
+ *
  * @par Example
  * @code
  * boost::asio::awaitable<void> echo(tcp::socket socket)
@@ -275,6 +302,11 @@ co_spawn(ExecutionContext& ctx, awaitable<T, AwaitableExecutor> a,
  *   echo(std::move(my_tcp_socket)),
  *   boost::asio::detached);
  * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * The new thread of execution is created with a cancellation state that
+ * supports @c cancellation_type::terminal values only. To change the
+ * cancellation state, call boost::asio::this_coro::reset_cancellation_state.
  */
 template <typename ExecutionContext, typename AwaitableExecutor,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(
@@ -302,14 +334,19 @@ co_spawn(ExecutionContext& ctx, awaitable<void, AwaitableExecutor> a,
  * @c boost::asio::awaitable<R,E> that will be used as the coroutine's entry
  * point.
  *
- * @param token The completion token that will handle the notification that the
- * thread of execution has completed. If @c R is @c void, the function
+ * @param token The @ref completion_token that will handle the notification
+ * that the thread of execution has completed. If @c R is @c void, the function
  * signature of the completion handler must be:
  *
  * @code void handler(std::exception_ptr); @endcode
  * Otherwise, the function signature of the completion handler must be:
  * @code void handler(std::exception_ptr, R); @endcode
  *
+ * @par Completion Signature
+ * @code void(std::exception_ptr, R) @endcode
+ * where @c R is the first template argument to the @c awaitable returned by the
+ * supplied function object @c F:
+ * @code boost::asio::awaitable<R, AwaitableExecutor> F() @endcode
  *
  * @par Example
  * @code
@@ -362,6 +399,11 @@ co_spawn(ExecutionContext& ctx, awaitable<void, AwaitableExecutor> a,
  *     }
  *   }, boost::asio::detached);
  * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * The new thread of execution is created with a cancellation state that
+ * supports @c cancellation_type::terminal values only. To change the
+ * cancellation state, call boost::asio::this_coro::reset_cancellation_state.
  */
 template <typename Executor, typename F,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::awaitable_signature<
@@ -385,14 +427,19 @@ co_spawn(const Executor& ex, F&& f,
  * @c boost::asio::awaitable<R,E> that will be used as the coroutine's entry
  * point.
  *
- * @param token The completion token that will handle the notification that the
- * thread of execution has completed. If @c R is @c void, the function
+ * @param token The @ref completion_token that will handle the notification
+ * that the thread of execution has completed. If @c R is @c void, the function
  * signature of the completion handler must be:
  *
  * @code void handler(std::exception_ptr); @endcode
  * Otherwise, the function signature of the completion handler must be:
  * @code void handler(std::exception_ptr, R); @endcode
  *
+ * @par Completion Signature
+ * @code void(std::exception_ptr, R) @endcode
+ * where @c R is the first template argument to the @c awaitable returned by the
+ * supplied function object @c F:
+ * @code boost::asio::awaitable<R, AwaitableExecutor> F() @endcode
  *
  * @par Example
  * @code
@@ -445,6 +492,11 @@ co_spawn(const Executor& ex, F&& f,
  *     }
  *   }, boost::asio::detached);
  * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * The new thread of execution is created with a cancellation state that
+ * supports @c cancellation_type::terminal values only. To change the
+ * cancellation state, call boost::asio::this_coro::reset_cancellation_state.
  */
 template <typename ExecutionContext, typename F,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::awaitable_signature<
diff --git a/boost/asio/completion_condition.hpp b/boost/asio/completion_condition.hpp
index 56414a20c512ad8f82c2e226ae54cb1cd7fe3315..bcca73e6a4aaf9a8ed7c804ae1cdd65a136f2fdc 100644
--- a/boost/asio/completion_condition.hpp
+++ b/boost/asio/completion_condition.hpp
@@ -2,7 +2,7 @@
 // completion_condition.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/compose.hpp b/boost/asio/compose.hpp
index 024b893b75e57c95837ee678399828c2376bd1f0..65ee97246cd98987c15e462fb419d85196b40e0c 100644
--- a/boost/asio/compose.hpp
+++ b/boost/asio/compose.hpp
@@ -2,7 +2,7 @@
 // compose.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/connect.hpp b/boost/asio/connect.hpp
index a6253875ae69565784235d6704d310b4180adda0..0aa8be63050841d91b64676958b4848c701a1a0a 100644
--- a/boost/asio/connect.hpp
+++ b/boost/asio/connect.hpp
@@ -2,7 +2,7 @@
 // connect.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -611,16 +611,19 @@ Iterator connect(basic_socket<Protocol, Executor>& s,
  * This function attempts to connect a socket to one of a sequence of
  * endpoints. It does this by repeated calls to the socket's @c async_connect
  * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
+ * is successfully established. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately.
  *
  * @param s The socket to be connected. If the socket is already open, it will
  * be closed.
  *
  * @param endpoints A sequence of endpoints.
  *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the connect completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation. if the sequence is empty, set to
  *   // boost::asio::error::not_found. Otherwise, contains the
@@ -632,10 +635,13 @@ Iterator connect(basic_socket<Protocol, Executor>& s,
  *   const typename Protocol::endpoint& endpoint
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, typename Protocol::endpoint) @endcode
+ *
  * @par Example
  * @code tcp::resolver r(my_context);
  * tcp::resolver::query q("host", "service");
@@ -665,16 +671,26 @@ Iterator connect(basic_socket<Protocol, Executor>& s,
  * {
  *   // ...
  * } @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the socket's @c async_connect operation.
  */
 template <typename Protocol, typename Executor, typename EndpointSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      typename Protocol::endpoint)) RangeConnectHandler
+      typename Protocol::endpoint)) RangeConnectToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(RangeConnectHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(RangeConnectToken,
     void (boost::system::error_code, typename Protocol::endpoint))
 async_connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints,
-    BOOST_ASIO_MOVE_ARG(RangeConnectHandler) handler
+    BOOST_ASIO_MOVE_ARG(RangeConnectToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
     typename constraint<is_endpoint_sequence<
         EndpointSequence>::value>::type = 0);
@@ -686,16 +702,19 @@ async_connect(basic_socket<Protocol, Executor>& s,
  * This function attempts to connect a socket to one of a sequence of
  * endpoints. It does this by repeated calls to the socket's @c async_connect
  * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
+ * is successfully established. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately.
  *
  * @param s The socket to be connected. If the socket is already open, it will
  * be closed.
  *
  * @param begin An iterator pointing to the start of a sequence of endpoints.
  *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the connect completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation. if the sequence is empty, set to
  *   // boost::asio::error::not_found. Otherwise, contains the
@@ -707,22 +726,35 @@ async_connect(basic_socket<Protocol, Executor>& s,
  *   Iterator iterator
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, Iterator) @endcode
+ *
  * @note This overload assumes that a default constructed object of type @c
  * Iterator represents the end of the sequence. This is a valid assumption for
  * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the socket's @c async_connect operation.
  */
 template <typename Protocol, typename Executor, typename Iterator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      Iterator)) IteratorConnectHandler
+      Iterator)) IteratorConnectToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
     typename constraint<!is_endpoint_sequence<Iterator>::value>::type = 0);
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
@@ -733,7 +765,8 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  * This function attempts to connect a socket to one of a sequence of
  * endpoints. It does this by repeated calls to the socket's @c async_connect
  * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
+ * is successfully established. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately.
  *
  * @param s The socket to be connected. If the socket is already open, it will
  * be closed.
@@ -742,9 +775,11 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  *
  * @param end An iterator pointing to the end of a sequence of endpoints.
  *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the connect completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation. if the sequence is empty, set to
  *   // boost::asio::error::not_found. Otherwise, contains the
@@ -756,10 +791,13 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  *   Iterator iterator
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, Iterator) @endcode
+ *
  * @par Example
  * @code std::vector<tcp::endpoint> endpoints = ...;
  * tcp::socket s(my_context);
@@ -775,15 +813,25 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  * {
  *   // ...
  * } @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the socket's @c async_connect operation.
  */
 template <typename Protocol, typename Executor, typename Iterator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      Iterator)) IteratorConnectHandler
+      Iterator)) IteratorConnectToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor));
 
 /// Asynchronously establishes a socket connection by trying each endpoint in a
@@ -792,7 +840,8 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
  * This function attempts to connect a socket to one of a sequence of
  * endpoints. It does this by repeated calls to the socket's @c async_connect
  * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
+ * is successfully established. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately.
  *
  * @param s The socket to be connected. If the socket is already open, it will
  * be closed.
@@ -810,9 +859,11 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
  * The function object should return true if the next endpoint should be tried,
  * and false if it should be skipped.
  *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the connect completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation. if the sequence is empty, set to
  *   // boost::asio::error::not_found. Otherwise, contains the
@@ -824,10 +875,13 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
  *   Iterator iterator
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, typename Protocol::endpoint) @endcode
+ *
  * @par Example
  * The following connect condition function object can be used to output
  * information about the individual connection attempts:
@@ -880,17 +934,27 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
  *     std::cout << "Connected to: " << endpoint << std::endl;
  *   }
  * } @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the socket's @c async_connect operation.
  */
 template <typename Protocol, typename Executor,
     typename EndpointSequence, typename ConnectCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      typename Protocol::endpoint)) RangeConnectHandler
+      typename Protocol::endpoint)) RangeConnectToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(RangeConnectHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(RangeConnectToken,
     void (boost::system::error_code, typename Protocol::endpoint))
 async_connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints, ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(RangeConnectHandler) handler
+    BOOST_ASIO_MOVE_ARG(RangeConnectToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
     typename constraint<is_endpoint_sequence<
         EndpointSequence>::value>::type = 0);
@@ -902,7 +966,8 @@ async_connect(basic_socket<Protocol, Executor>& s,
  * This function attempts to connect a socket to one of a sequence of
  * endpoints. It does this by repeated calls to the socket's @c async_connect
  * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
+ * is successfully established. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately.
  *
  * @param s The socket to be connected. If the socket is already open, it will
  * be closed.
@@ -920,9 +985,11 @@ async_connect(basic_socket<Protocol, Executor>& s,
  * The function object should return true if the next endpoint should be tried,
  * and false if it should be skipped.
  *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the connect completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation. if the sequence is empty, set to
  *   // boost::asio::error::not_found. Otherwise, contains the
@@ -934,24 +1001,37 @@ async_connect(basic_socket<Protocol, Executor>& s,
  *   Iterator iterator
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, Iterator) @endcode
+ *
  * @note This overload assumes that a default constructed object of type @c
  * Iterator represents the end of the sequence. This is a valid assumption for
  * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the socket's @c async_connect operation.
  */
 template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      Iterator)) IteratorConnectHandler
+      Iterator)) IteratorConnectToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
     ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
     typename constraint<!is_endpoint_sequence<Iterator>::value>::type = 0);
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
@@ -962,7 +1042,8 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  * This function attempts to connect a socket to one of a sequence of
  * endpoints. It does this by repeated calls to the socket's @c async_connect
  * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
+ * is successfully established. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately.
  *
  * @param s The socket to be connected. If the socket is already open, it will
  * be closed.
@@ -982,9 +1063,11 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  * The function object should return true if the next endpoint should be tried,
  * and false if it should be skipped.
  *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the connect completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation. if the sequence is empty, set to
  *   // boost::asio::error::not_found. Otherwise, contains the
@@ -996,10 +1079,13 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  *   Iterator iterator
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, Iterator) @endcode
+ *
  * @par Example
  * The following connect condition function object can be used to output
  * information about the individual connection attempts:
@@ -1053,17 +1139,27 @@ async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
  *     std::cout << "Connected to: " << i->endpoint() << std::endl;
  *   }
  * } @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the socket's @c async_connect operation.
  */
 template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      Iterator)) IteratorConnectHandler
+      Iterator)) IteratorConnectToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
     Iterator end, ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor));
 
 /*@}*/
diff --git a/boost/asio/connect_pipe.hpp b/boost/asio/connect_pipe.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..fb9e58736c9a241c55cfed171707ecce68f4c1c0
--- /dev/null
+++ b/boost/asio/connect_pipe.hpp
@@ -0,0 +1,85 @@
+//
+// connect_pipe.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_CONNECT_PIPE_HPP
+#define BOOST_ASIO_CONNECT_PIPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_PIPE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <boost/asio/basic_readable_pipe.hpp>
+#include <boost/asio/basic_writable_pipe.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+typedef HANDLE native_pipe_handle;
+#else // defined(BOOST_ASIO_HAS_IOCP)
+typedef int native_pipe_handle;
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
+BOOST_ASIO_DECL void create_pipe(native_pipe_handle p[2],
+    boost::system::error_code& ec);
+
+BOOST_ASIO_DECL void close_pipe(native_pipe_handle p);
+
+} // namespace detail
+
+/// Connect two pipe ends using an anonymous pipe.
+/**
+ * @param read_end The read end of the pipe.
+ *
+ * @param write_end The write end of the pipe.
+ *
+ * @throws boost::system::system_error Thrown on failure.
+ */
+template <typename Executor1, typename Executor2>
+void connect_pipe(basic_readable_pipe<Executor1>& read_end,
+    basic_writable_pipe<Executor2>& write_end);
+
+/// Connect two pipe ends using an anonymous pipe.
+/**
+ * @param read_end The read end of the pipe.
+ *
+ * @param write_end The write end of the pipe.
+ *
+ * @throws boost::system::system_error Thrown on failure.
+ *
+ * @param ec Set to indicate what error occurred, if any.
+ */
+template <typename Executor1, typename Executor2>
+BOOST_ASIO_SYNC_OP_VOID connect_pipe(basic_readable_pipe<Executor1>& read_end,
+    basic_writable_pipe<Executor2>& write_end, boost::system::error_code& ec);
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/impl/connect_pipe.hpp>
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/impl/connect_pipe.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // defined(BOOST_ASIO_HAS_PIPE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_CONNECT_PIPE_HPP
diff --git a/boost/asio/coroutine.hpp b/boost/asio/coroutine.hpp
index 3be129a4c4526a8d9f47699ed16176e0ce6cdae4..61d09a250785772e77a48fd99c76505fce673c51 100644
--- a/boost/asio/coroutine.hpp
+++ b/boost/asio/coroutine.hpp
@@ -2,7 +2,7 @@
 // coroutine.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/deadline_timer.hpp b/boost/asio/deadline_timer.hpp
index f764e51471972059b64cac47561abb8f89cf2b3b..91c80e3cf83ed7defd752f4f5e152e16317a95f2 100644
--- a/boost/asio/deadline_timer.hpp
+++ b/boost/asio/deadline_timer.hpp
@@ -2,7 +2,7 @@
 // deadline_timer.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/defer.hpp b/boost/asio/defer.hpp
index b9537d5b5eb1076ecda403334bce7f6f899364ef..2411f7f55a3527379a75a2c05ad111fff4061ea9 100644
--- a/boost/asio/defer.hpp
+++ b/boost/asio/defer.hpp
@@ -2,7 +2,7 @@
 // defer.hpp
 // ~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -38,27 +38,48 @@ namespace asio {
  * may allow the executor to optimise queueing for cases when the function
  * object represents a continuation of the current call context.
  *
- * This function has the following effects:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler. The function signature of the completion handler must be:
+ * @code void handler(); @endcode
  *
- * @li Constructs a function object handler of type @c Handler, initialized
- * with <tt>handler(forward<CompletionToken>(token))</tt>.
+ * @returns This function returns <tt>async_initiate<NullaryToken,
+ * void()>(Init{}, token)</tt>, where @c Init is a function object type defined
+ * as:
  *
- * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
- * initializing the object as <tt>result(handler)</tt>.
+ * @code class Init
+ * {
+ * public:
+ *   template <typename CompletionHandler>
+ *     void operator()(CompletionHandler&& completion_handler) const;
+ * }; @endcode
  *
- * @li Obtains the handler's associated executor object @c ex by performing
- * <tt>get_associated_executor(handler)</tt>.
+ * The function call operator of @c Init:
  *
- * @li Obtains the handler's associated allocator object @c alloc by performing
- * <tt>get_associated_allocator(handler)</tt>.
- *
- * @li Performs <tt>ex.defer(std::move(handler), alloc)</tt>.
+ * @li Obtains the handler's associated executor object @c ex of type @c Ex by
+ * performing @code auto ex = get_associated_executor(handler); @endcode
  *
- * @li Returns <tt>result.get()</tt>.
+ * @li Obtains the handler's associated allocator object @c alloc by performing
+ * @code auto alloc = get_associated_allocator(handler); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
+ * @code execution::execute(
+ *     prefer(
+ *       require(ex, execution::blocking.never),
+ *       execution::relationship.continuation,
+ *       execution::allocator(alloc)),
+ *     std::forward<CompletionHandler>(completion_handler)); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
+ * @code ex.defer(
+ *     std::forward<CompletionHandler>(completion_handler),
+ *     alloc); @endcode
+ *
+ * @par Completion Signature
+ * @code void() @endcode
  */
-template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) defer(
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token);
+template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) defer(
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token);
 
 /// Submits a completion token or function object for execution.
 /**
@@ -71,36 +92,76 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) defer(
  * may allow the executor to optimise queueing for cases when the function
  * object represents a continuation of the current call context.
  *
- * This function has the following effects:
- *
- * @li Constructs a function object handler of type @c Handler, initialized
- * with <tt>handler(forward<CompletionToken>(token))</tt>.
- *
- * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
- * initializing the object as <tt>result(handler)</tt>.
+ * @param ex The target executor.
  *
- * @li Obtains the handler's associated executor object @c ex1 by performing
- * <tt>get_associated_executor(handler)</tt>.
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler. The function signature of the completion handler must be:
+ * @code void handler(); @endcode
  *
- * @li Creates a work object @c w by performing <tt>make_work(ex1)</tt>.
+ * @returns This function returns <tt>async_initiate<NullaryToken,
+ * void()>(Init{ex}, token)</tt>, where @c Init is a function object type
+ * defined as:
  *
- * @li Obtains the handler's associated allocator object @c alloc by performing
- * <tt>get_associated_allocator(handler)</tt>.
+ * @code class Init
+ * {
+ * public:
+ *   using executor_type = Executor;
+ *   explicit Init(const Executor& ex) : ex_(ex) {}
+ *   executor_type get_executor() const noexcept { return ex_; }
+ *   template <typename CompletionHandler>
+ *     void operator()(CompletionHandler&& completion_handler) const;
+ * private:
+ *   Executor ex_; // exposition only
+ * }; @endcode
  *
- * @li Constructs a function object @c f with a function call operator that
- * performs <tt>ex1.dispatch(std::move(handler), alloc)</tt> followed by
- * <tt>w.reset()</tt>.
+ * The function call operator of @c Init:
  *
- * @li Performs <tt>Executor(ex).defer(std::move(f), alloc)</tt>.
+ * @li Obtains the handler's associated executor object @c ex1 of type @c Ex1 by
+ * performing @code auto ex1 = get_associated_executor(handler, ex); @endcode
  *
- * @li Returns <tt>result.get()</tt>.
+ * @li Obtains the handler's associated allocator object @c alloc by performing
+ * @code auto alloc = get_associated_allocator(handler); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex1>::value</tt> is true, constructs a
+ * function object @c f with a member @c executor_ that is initialised with
+ * <tt>prefer(ex1, execution::outstanding_work.tracked)</tt>, a member @c
+ * handler_ that is a decay-copy of @c completion_handler, and a function call
+ * operator that performs:
+ * @code auto a = get_associated_allocator(handler_);
+ * execution::execute(
+ *     prefer(executor_,
+ *       execution::blocking.possibly,
+ *       execution::allocator(a)),
+ *     std::move(handler_)); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex1>::value</tt> is false, constructs a
+ * function object @c f with a member @c work_ that is initialised with
+ * <tt>make_work_guard(ex1)</tt>, a member @c handler_ that is a decay-copy of
+ * @c completion_handler, and a function call operator that performs:
+ * @code auto a = get_associated_allocator(handler_);
+ * work_.get_executor().dispatch(std::move(handler_), a);
+ * work_.reset(); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
+ * @code execution::execute(
+ *     prefer(
+ *       require(ex, execution::blocking.never),
+ *       execution::relationship.continuation,
+ *       execution::allocator(alloc)),
+ *     std::move(f)); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
+ * @code ex.defer(std::move(f), alloc); @endcode
+ *
+ * @par Completion Signature
+ * @code void() @endcode
  */
 template <typename Executor,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) defer(
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) defer(
     const Executor& ex,
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
     typename constraint<
       execution::is_executor<Executor>::value || is_executor<Executor>::value
@@ -108,15 +169,24 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) defer(
 
 /// Submits a completion token or function object for execution.
 /**
- * @returns <tt>defer(ctx.get_executor(), forward<CompletionToken>(token))</tt>.
+ * @param ctx An execution context, from which the target executor is obtained.
+ *
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler. The function signature of the completion handler must be:
+ * @code void handler(); @endcode
+ *
+ * @returns <tt>defer(ctx.get_executor(), forward<NullaryToken>(token))</tt>.
+ *
+ * @par Completion Signature
+ * @code void() @endcode
  */
 template <typename ExecutionContext,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
         typename ExecutionContext::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) defer(
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) defer(
     ExecutionContext& ctx,
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename ExecutionContext::executor_type),
     typename constraint<is_convertible<
diff --git a/boost/asio/detached.hpp b/boost/asio/detached.hpp
index 0447a45c639e67c01fcee0cd8669a3b88486acf6..ac3adb287c60d106bcafc2e9e2ad096844577d08 100644
--- a/boost/asio/detached.hpp
+++ b/boost/asio/detached.hpp
@@ -2,7 +2,7 @@
 // detached.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/array.hpp b/boost/asio/detail/array.hpp
index 4763f427dce96ff1624124c9501129fb66e7bf96..fa868060c067aebe70f5a69386bbcd935f9adeb4 100644
--- a/boost/asio/detail/array.hpp
+++ b/boost/asio/detail/array.hpp
@@ -2,7 +2,7 @@
 // detail/array.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/array_fwd.hpp b/boost/asio/detail/array_fwd.hpp
index 3ba0b2675c5ed17e36e2bb4710047a87faf76054..7a8f7266c2a8f6a907b8fd5c69082878f148c091 100644
--- a/boost/asio/detail/array_fwd.hpp
+++ b/boost/asio/detail/array_fwd.hpp
@@ -2,7 +2,7 @@
 // detail/array_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/assert.hpp b/boost/asio/detail/assert.hpp
index 0a3add07ea1f10aa5dfa56223bfdf2cf33087d9a..b54503ba20df5c482a0a7ac7164226759a071ec0 100644
--- a/boost/asio/detail/assert.hpp
+++ b/boost/asio/detail/assert.hpp
@@ -2,7 +2,7 @@
 // detail/assert.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/atomic_count.hpp b/boost/asio/detail/atomic_count.hpp
index 1cd6f9d151989f8693812bc82bbb3f1e1f55e6ea..a24fb5cdc65b702ad93fc53b510895278476f860 100644
--- a/boost/asio/detail/atomic_count.hpp
+++ b/boost/asio/detail/atomic_count.hpp
@@ -2,7 +2,7 @@
 // detail/atomic_count.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -32,11 +32,13 @@ namespace detail {
 #if !defined(BOOST_ASIO_HAS_THREADS)
 typedef long atomic_count;
 inline void increment(atomic_count& a, long b) { a += b; }
+inline void decrement(atomic_count& a, long b) { a -= b; }
 inline void ref_count_up(atomic_count& a) { ++a; }
 inline bool ref_count_down(atomic_count& a) { return --a == 0; }
 #elif defined(BOOST_ASIO_HAS_STD_ATOMIC)
 typedef std::atomic<long> atomic_count;
 inline void increment(atomic_count& a, long b) { a += b; }
+inline void decrement(atomic_count& a, long b) { a -= b; }
 
 inline void ref_count_up(atomic_count& a)
 {
@@ -55,6 +57,7 @@ inline bool ref_count_down(atomic_count& a)
 #else // defined(BOOST_ASIO_HAS_STD_ATOMIC)
 typedef boost::detail::atomic_count atomic_count;
 inline void increment(atomic_count& a, long b) { while (b > 0) ++a, --b; }
+inline void decrement(atomic_count& a, long b) { while (b > 0) --a, --b; }
 inline void ref_count_up(atomic_count& a) { ++a; }
 inline bool ref_count_down(atomic_count& a) { return --a == 0; }
 #endif // defined(BOOST_ASIO_HAS_STD_ATOMIC)
diff --git a/boost/asio/detail/base_from_cancellation_state.hpp b/boost/asio/detail/base_from_cancellation_state.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..62170cd7e7ea51e2848030612adf6e039d603064
--- /dev/null
+++ b/boost/asio/detail/base_from_cancellation_state.hpp
@@ -0,0 +1,165 @@
+//
+// detail/base_from_cancellation_state.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_BASE_FROM_CANCELLATION_STATE_HPP
+#define BOOST_ASIO_DETAIL_BASE_FROM_CANCELLATION_STATE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/cancellation_state.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Handler, typename = void>
+class base_from_cancellation_state
+{
+public:
+  typedef cancellation_slot cancellation_slot_type;
+
+  cancellation_slot_type get_cancellation_slot() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_state_.slot();
+  }
+
+  cancellation_state get_cancellation_state() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_state_;
+  }
+
+protected:
+  explicit base_from_cancellation_state(const Handler& handler)
+    : cancellation_state_(
+        boost::asio::get_associated_cancellation_slot(handler))
+  {
+  }
+
+  template <typename Filter>
+  base_from_cancellation_state(const Handler& handler, Filter filter)
+    : cancellation_state_(
+        boost::asio::get_associated_cancellation_slot(handler), filter, filter)
+  {
+  }
+
+  template <typename InFilter, typename OutFilter>
+  base_from_cancellation_state(const Handler& handler,
+      BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
+      BOOST_ASIO_MOVE_ARG(OutFilter) out_filter)
+    : cancellation_state_(
+        boost::asio::get_associated_cancellation_slot(handler),
+        BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
+        BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter))
+  {
+  }
+
+  void reset_cancellation_state(const Handler& handler)
+  {
+    cancellation_state_ = cancellation_state(
+        boost::asio::get_associated_cancellation_slot(handler));
+  }
+
+  template <typename Filter>
+  void reset_cancellation_state(const Handler& handler, Filter filter)
+  {
+    cancellation_state_ = cancellation_state(
+        boost::asio::get_associated_cancellation_slot(handler), filter, filter);
+  }
+
+  template <typename InFilter, typename OutFilter>
+  void reset_cancellation_state(const Handler& handler,
+      BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
+      BOOST_ASIO_MOVE_ARG(OutFilter) out_filter)
+  {
+    cancellation_state_ = cancellation_state(
+        boost::asio::get_associated_cancellation_slot(handler),
+        BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
+        BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter));
+  }
+
+  cancellation_type_t cancelled() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_state_.cancelled();
+  }
+
+private:
+  cancellation_state cancellation_state_;
+};
+
+template <typename Handler>
+class base_from_cancellation_state<Handler,
+    typename enable_if<
+      is_same<
+        typename associated_cancellation_slot<
+          Handler, cancellation_slot
+        >::asio_associated_cancellation_slot_is_unspecialised,
+        void
+      >::value
+    >::type>
+{
+public:
+  cancellation_state get_cancellation_state() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_state();
+  }
+
+protected:
+  explicit base_from_cancellation_state(const Handler&)
+  {
+  }
+
+  template <typename Filter>
+  base_from_cancellation_state(const Handler&, Filter)
+  {
+  }
+
+  template <typename InFilter, typename OutFilter>
+  base_from_cancellation_state(const Handler&,
+      BOOST_ASIO_MOVE_ARG(InFilter),
+      BOOST_ASIO_MOVE_ARG(OutFilter))
+  {
+  }
+
+  void reset_cancellation_state(const Handler&)
+  {
+  }
+
+  template <typename Filter>
+  void reset_cancellation_state(const Handler&, Filter)
+  {
+  }
+
+  template <typename InFilter, typename OutFilter>
+  void reset_cancellation_state(const Handler&,
+      BOOST_ASIO_MOVE_ARG(InFilter),
+      BOOST_ASIO_MOVE_ARG(OutFilter))
+  {
+  }
+
+  BOOST_ASIO_CONSTEXPR cancellation_type_t cancelled() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_type::none;
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_BASE_FROM_CANCELLATION_STATE_HPP
diff --git a/boost/asio/detail/base_from_completion_cond.hpp b/boost/asio/detail/base_from_completion_cond.hpp
index cf4a1b768b8e8578e8d244e89fb81e6143367ef7..3af86cff51b2fe8374aa5737ba8803c22c677b0f 100644
--- a/boost/asio/detail/base_from_completion_cond.hpp
+++ b/boost/asio/detail/base_from_completion_cond.hpp
@@ -2,7 +2,7 @@
 // detail/base_from_completion_cond.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/bind_handler.hpp b/boost/asio/detail/bind_handler.hpp
index dcf2cc1b1371a2228d84bdcffe01230910b829ad..3cdb0830a8a6eb39a585fba8c01b1b86f9d72546 100644
--- a/boost/asio/detail/bind_handler.hpp
+++ b/boost/asio/detail/bind_handler.hpp
@@ -2,7 +2,7 @@
 // detail/bind_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,8 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associator.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>
@@ -29,6 +28,113 @@ namespace boost {
 namespace asio {
 namespace detail {
 
+template <typename Handler>
+class binder0
+{
+public:
+  template <typename T>
+  binder0(int, BOOST_ASIO_MOVE_ARG(T) handler)
+    : handler_(BOOST_ASIO_MOVE_CAST(T)(handler))
+  {
+  }
+
+  binder0(Handler& handler)
+    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  binder0(const binder0& other)
+    : handler_(other.handler_)
+  {
+  }
+
+  binder0(binder0&& other)
+    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_))
+  {
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  void operator()()
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)();
+  }
+
+  void operator()() const
+  {
+    handler_();
+  }
+
+//private:
+  Handler handler_;
+};
+
+template <typename Handler>
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
+    binder0<Handler>* this_handler)
+{
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
+  return boost_asio_handler_alloc_helpers::allocate(
+      size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
+    binder0<Handler>* this_handler)
+{
+  boost_asio_handler_alloc_helpers::deallocate(
+      pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline bool asio_handler_is_continuation(
+    binder0<Handler>* this_handler)
+{
+  return boost_asio_handler_cont_helpers::is_continuation(
+      this_handler->handler_);
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
+    binder0<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
+    binder0<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline binder0<typename decay<Handler>::type> bind_handler(
+    BOOST_ASIO_MOVE_ARG(Handler) handler)
+{
+  return binder0<typename decay<Handler>::type>(
+      0, BOOST_ASIO_MOVE_CAST(Handler)(handler));
+}
+
 template <typename Handler, typename Arg1>
 class binder1
 {
@@ -62,7 +168,8 @@ public:
 
   void operator()()
   {
-    handler_(static_cast<const Arg1&>(arg1_));
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        static_cast<const Arg1&>(arg1_));
   }
 
   void operator()() const
@@ -179,7 +286,8 @@ public:
 
   void operator()()
   {
-    handler_(static_cast<const Arg1&>(arg1_),
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        static_cast<const Arg1&>(arg1_),
         static_cast<const Arg2&>(arg2_));
   }
 
@@ -303,8 +411,10 @@ public:
 
   void operator()()
   {
-    handler_(static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_));
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        static_cast<const Arg1&>(arg1_),
+        static_cast<const Arg2&>(arg2_),
+        static_cast<const Arg3&>(arg3_));
   }
 
   void operator()() const
@@ -436,8 +546,10 @@ public:
 
   void operator()()
   {
-    handler_(static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_),
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        static_cast<const Arg1&>(arg1_),
+        static_cast<const Arg2&>(arg2_),
+        static_cast<const Arg3&>(arg3_),
         static_cast<const Arg4&>(arg4_));
   }
 
@@ -579,9 +691,12 @@ public:
 
   void operator()()
   {
-    handler_(static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_),
-        static_cast<const Arg4&>(arg4_), static_cast<const Arg5&>(arg5_));
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        static_cast<const Arg1&>(arg1_),
+        static_cast<const Arg2&>(arg2_),
+        static_cast<const Arg3&>(arg3_),
+        static_cast<const Arg4&>(arg4_),
+        static_cast<const Arg5&>(arg5_));
   }
 
   void operator()() const
@@ -692,7 +807,8 @@ public:
 
   void operator()()
   {
-    handler_(BOOST_ASIO_MOVE_CAST(Arg1)(arg1_));
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        BOOST_ASIO_MOVE_CAST(Arg1)(arg1_));
   }
 
 //private:
@@ -767,7 +883,8 @@ public:
 
   void operator()()
   {
-    handler_(static_cast<const Arg1&>(arg1_),
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        static_cast<const Arg1&>(arg1_),
         BOOST_ASIO_MOVE_CAST(Arg2)(arg2_));
   }
 
@@ -827,106 +944,122 @@ asio_handler_invoke(BOOST_ASIO_MOVE_ARG(Function) function,
 
 } // namespace detail
 
-template <typename Handler, typename Arg1, typename Allocator>
-struct associated_allocator<detail::binder1<Handler, Arg1>, Allocator>
+template <template <typename, typename> class Associator,
+    typename Handler, typename DefaultCandidate>
+struct associator<Associator,
+    detail::binder0<Handler>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(const detail::binder1<Handler, Arg1>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const detail::binder0<Handler>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
-template <typename Handler, typename Arg1, typename Arg2, typename Allocator>
-struct associated_allocator<detail::binder2<Handler, Arg1, Arg2>, Allocator>
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename DefaultCandidate>
+struct associator<Associator,
+    detail::binder1<Handler, Arg1>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(const detail::binder2<Handler, Arg1, Arg2>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const detail::binder1<Handler, Arg1>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
-template <typename Handler, typename Arg1, typename Executor>
-struct associated_executor<detail::binder1<Handler, Arg1>, Executor>
-  : detail::associated_executor_forwarding_base<Handler, Executor>
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename Arg2,
+    typename DefaultCandidate>
+struct associator<Associator,
+    detail::binder2<Handler, Arg1, Arg2>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_executor<Handler, Executor>::type type;
-
-  static type get(const detail::binder1<Handler, Arg1>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const detail::binder2<Handler, Arg1, Arg2>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
-template <typename Handler, typename Arg1, typename Arg2, typename Executor>
-struct associated_executor<detail::binder2<Handler, Arg1, Arg2>, Executor>
-  : detail::associated_executor_forwarding_base<Handler, Executor>
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename Arg2, typename Arg3,
+    typename DefaultCandidate>
+struct associator<Associator,
+    detail::binder3<Handler, Arg1, Arg2, Arg3>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_executor<Handler, Executor>::type type;
-
-  static type get(const detail::binder2<Handler, Arg1, Arg2>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const detail::binder3<Handler, Arg1, Arg2, Arg3>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-
-template <typename Handler, typename Arg1, typename Allocator>
-struct associated_allocator<detail::move_binder1<Handler, Arg1>, Allocator>
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename Arg2, typename Arg3,
+    typename Arg4, typename DefaultCandidate>
+struct associator<Associator,
+    detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(const detail::move_binder1<Handler, Arg1>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
-template <typename Handler, typename Arg1, typename Arg2, typename Allocator>
-struct associated_allocator<
-    detail::move_binder2<Handler, Arg1, Arg2>, Allocator>
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename Arg2, typename Arg3,
+    typename Arg4, typename Arg5, typename DefaultCandidate>
+struct associator<Associator,
+    detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
-template <typename Handler, typename Arg1, typename Executor>
-struct associated_executor<detail::move_binder1<Handler, Arg1>, Executor>
-  : detail::associated_executor_forwarding_base<Handler, Executor>
-{
-  typedef typename associated_executor<Handler, Executor>::type type;
+#if defined(BOOST_ASIO_HAS_MOVE)
 
-  static type get(const detail::move_binder1<Handler, Arg1>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename DefaultCandidate>
+struct associator<Associator,
+    detail::move_binder1<Handler, Arg1>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const detail::move_binder1<Handler, Arg1>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
-template <typename Handler, typename Arg1, typename Arg2, typename Executor>
-struct associated_executor<detail::move_binder2<Handler, Arg1, Arg2>, Executor>
-  : detail::associated_executor_forwarding_base<Handler, Executor>
+template <template <typename, typename> class Associator,
+    typename Handler, typename Arg1, typename Arg2,
+    typename DefaultCandidate>
+struct associator<Associator,
+    detail::move_binder2<Handler, Arg1, Arg2>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_executor<Handler, Executor>::type type;
-
-  static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const detail::move_binder2<Handler, Arg1, Arg2>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
diff --git a/boost/asio/detail/blocking_executor_op.hpp b/boost/asio/detail/blocking_executor_op.hpp
index e36bb989752bc3ff17f3b45d611a69fd9e582f44..f189fd4b74344fe337b5c27e8007959aa36e820c 100644
--- a/boost/asio/detail/blocking_executor_op.hpp
+++ b/boost/asio/detail/blocking_executor_op.hpp
@@ -2,7 +2,7 @@
 // detail/blocking_executor_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/buffer_resize_guard.hpp b/boost/asio/detail/buffer_resize_guard.hpp
index 45da2db28d5dcf15c65555ef30fa72cfe809f7b4..d2352589628d53dc87b01718716c2d81286daccd 100644
--- a/boost/asio/detail/buffer_resize_guard.hpp
+++ b/boost/asio/detail/buffer_resize_guard.hpp
@@ -2,7 +2,7 @@
 // detail/buffer_resize_guard.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/buffer_sequence_adapter.hpp b/boost/asio/detail/buffer_sequence_adapter.hpp
index ad07bd9a292331bbfd96b0e9ab97ec752e83a9f1..ed671536cae2fac5c51de79c38888c6087e9ba92 100644
--- a/boost/asio/detail/buffer_sequence_adapter.hpp
+++ b/boost/asio/detail/buffer_sequence_adapter.hpp
@@ -2,7 +2,7 @@
 // detail/buffer_sequence_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,6 +19,7 @@
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/detail/array_fwd.hpp>
 #include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/registered_buffer.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -106,6 +107,7 @@ class buffer_sequence_adapter
 {
 public:
   enum { is_single_buffer = false };
+  enum { is_registered_buffer = false };
 
   explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
     : count_(0), total_buffer_size_(0)
@@ -130,6 +132,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -249,6 +256,7 @@ class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffer>
 {
 public:
   enum { is_single_buffer = true };
+  enum { is_registered_buffer = false };
 
   explicit buffer_sequence_adapter(
       const boost::asio::mutable_buffer& buffer_sequence)
@@ -272,6 +280,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -311,6 +324,7 @@ class buffer_sequence_adapter<Buffer, boost::asio::const_buffer>
 {
 public:
   enum { is_single_buffer = true };
+  enum { is_registered_buffer = false };
 
   explicit buffer_sequence_adapter(
       const boost::asio::const_buffer& buffer_sequence)
@@ -334,6 +348,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -375,6 +394,7 @@ class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffers_1>
 {
 public:
   enum { is_single_buffer = true };
+  enum { is_registered_buffer = false };
 
   explicit buffer_sequence_adapter(
       const boost::asio::mutable_buffers_1& buffer_sequence)
@@ -398,6 +418,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -437,6 +462,7 @@ class buffer_sequence_adapter<Buffer, boost::asio::const_buffers_1>
 {
 public:
   enum { is_single_buffer = true };
+  enum { is_registered_buffer = false };
 
   explicit buffer_sequence_adapter(
       const boost::asio::const_buffers_1& buffer_sequence)
@@ -460,6 +486,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -495,12 +526,161 @@ private:
 
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
+template <typename Buffer>
+class buffer_sequence_adapter<Buffer, boost::asio::mutable_registered_buffer>
+  : buffer_sequence_adapter_base
+{
+public:
+  enum { is_single_buffer = true };
+  enum { is_registered_buffer = true };
+
+  explicit buffer_sequence_adapter(
+      const boost::asio::mutable_registered_buffer& buffer_sequence)
+  {
+    init_native_buffer(buffer_, buffer_sequence.buffer());
+    total_buffer_size_ = buffer_sequence.size();
+    registered_id_ = buffer_sequence.id();
+  }
+
+  native_buffer_type* buffers()
+  {
+    return &buffer_;
+  }
+
+  std::size_t count() const
+  {
+    return 1;
+  }
+
+  std::size_t total_size() const
+  {
+    return total_buffer_size_;
+  }
+
+  registered_buffer_id registered_id() const
+  {
+    return registered_id_;
+  }
+
+  bool all_empty() const
+  {
+    return total_buffer_size_ == 0;
+  }
+
+  static bool all_empty(
+      const boost::asio::mutable_registered_buffer& buffer_sequence)
+  {
+    return buffer_sequence.size() == 0;
+  }
+
+  static void validate(
+      const boost::asio::mutable_registered_buffer& buffer_sequence)
+  {
+    buffer_sequence.data();
+  }
+
+  static Buffer first(
+      const boost::asio::mutable_registered_buffer& buffer_sequence)
+  {
+    return Buffer(buffer_sequence.buffer());
+  }
+
+  enum { linearisation_storage_size = 1 };
+
+  static Buffer linearise(
+      const boost::asio::mutable_registered_buffer& buffer_sequence,
+      const Buffer&)
+  {
+    return Buffer(buffer_sequence.buffer());
+  }
+
+private:
+  native_buffer_type buffer_;
+  std::size_t total_buffer_size_;
+  registered_buffer_id registered_id_;
+};
+
+template <typename Buffer>
+class buffer_sequence_adapter<Buffer, boost::asio::const_registered_buffer>
+  : buffer_sequence_adapter_base
+{
+public:
+  enum { is_single_buffer = true };
+  enum { is_registered_buffer = true };
+
+  explicit buffer_sequence_adapter(
+      const boost::asio::const_registered_buffer& buffer_sequence)
+  {
+    init_native_buffer(buffer_, buffer_sequence.buffer());
+    total_buffer_size_ = buffer_sequence.size();
+    registered_id_ = buffer_sequence.id();
+  }
+
+  native_buffer_type* buffers()
+  {
+    return &buffer_;
+  }
+
+  std::size_t count() const
+  {
+    return 1;
+  }
+
+  std::size_t total_size() const
+  {
+    return total_buffer_size_;
+  }
+
+  registered_buffer_id registered_id() const
+  {
+    return registered_id_;
+  }
+
+  bool all_empty() const
+  {
+    return total_buffer_size_ == 0;
+  }
+
+  static bool all_empty(
+      const boost::asio::const_registered_buffer& buffer_sequence)
+  {
+    return buffer_sequence.size() == 0;
+  }
+
+  static void validate(
+      const boost::asio::const_registered_buffer& buffer_sequence)
+  {
+    buffer_sequence.data();
+  }
+
+  static Buffer first(
+      const boost::asio::const_registered_buffer& buffer_sequence)
+  {
+    return Buffer(buffer_sequence.buffer());
+  }
+
+  enum { linearisation_storage_size = 1 };
+
+  static Buffer linearise(
+      const boost::asio::const_registered_buffer& buffer_sequence,
+      const Buffer&)
+  {
+    return Buffer(buffer_sequence.buffer());
+  }
+
+private:
+  native_buffer_type buffer_;
+  std::size_t total_buffer_size_;
+  registered_buffer_id registered_id_;
+};
+
 template <typename Buffer, typename Elem>
 class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
   : buffer_sequence_adapter_base
 {
 public:
   enum { is_single_buffer = false };
+  enum { is_registered_buffer = false };
 
   explicit buffer_sequence_adapter(
       const boost::array<Elem, 2>& buffer_sequence)
@@ -525,6 +705,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
@@ -573,6 +758,7 @@ class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
 {
 public:
   enum { is_single_buffer = false };
+  enum { is_registered_buffer = false };
 
   explicit buffer_sequence_adapter(
       const std::array<Elem, 2>& buffer_sequence)
@@ -597,6 +783,11 @@ public:
     return total_buffer_size_;
   }
 
+  registered_buffer_id registered_id() const
+  {
+    return registered_buffer_id();
+  }
+
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
diff --git a/boost/asio/detail/buffered_stream_storage.hpp b/boost/asio/detail/buffered_stream_storage.hpp
index eefccee336f0eadbdf14282e8d0cfe4f3c5eb878..be0194601935ebef924201c209da70f675687f52 100644
--- a/boost/asio/detail/buffered_stream_storage.hpp
+++ b/boost/asio/detail/buffered_stream_storage.hpp
@@ -2,7 +2,7 @@
 // detail/buffered_stream_storage.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/bulk_executor_op.hpp b/boost/asio/detail/bulk_executor_op.hpp
index 866aaf864a05e5d430637b72895991e38395c42e..6d457c42e520ba04d80190d2daca8b93ae4308cf 100644
--- a/boost/asio/detail/bulk_executor_op.hpp
+++ b/boost/asio/detail/bulk_executor_op.hpp
@@ -2,7 +2,7 @@
 // detail/bulk_executor_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/call_stack.hpp b/boost/asio/detail/call_stack.hpp
index e1860ed4890e7594c3f64e91fdf2c0f1d292338e..4a01e89228ca64952c0829f7275531b250dcd759 100644
--- a/boost/asio/detail/call_stack.hpp
+++ b/boost/asio/detail/call_stack.hpp
@@ -2,7 +2,7 @@
 // detail/call_stack.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/chrono.hpp b/boost/asio/detail/chrono.hpp
index 548910c5ffa1b8a64e1d823f0432ccf3d14cbb86..9d3b81174a7c6d0268788ebde2e68edbb653317a 100644
--- a/boost/asio/detail/chrono.hpp
+++ b/boost/asio/detail/chrono.hpp
@@ -2,7 +2,7 @@
 // detail/chrono.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/chrono_time_traits.hpp b/boost/asio/detail/chrono_time_traits.hpp
index 11325657d674e9d3be83aa9c12748a89d17ca9fa..d5fbb89394b2d7847d73a00a57dce7686ed0a18f 100644
--- a/boost/asio/detail/chrono_time_traits.hpp
+++ b/boost/asio/detail/chrono_time_traits.hpp
@@ -2,7 +2,7 @@
 // detail/chrono_time_traits.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/completion_handler.hpp b/boost/asio/detail/completion_handler.hpp
index d641c9ffa89ae137c95e25b21c1b323ccd5b1851..76927e6b8306c3f7286cd5ad0824e9466bf9fc7e 100644
--- a/boost/asio/detail/completion_handler.hpp
+++ b/boost/asio/detail/completion_handler.hpp
@@ -2,7 +2,7 @@
 // detail/completion_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/concurrency_hint.hpp b/boost/asio/detail/concurrency_hint.hpp
index f27112c48c1b0af47e570b7ff340163010ff6e2e..3febc0018ce667e2c745d4583816efa8d5fee3f7 100644
--- a/boost/asio/detail/concurrency_hint.hpp
+++ b/boost/asio/detail/concurrency_hint.hpp
@@ -2,7 +2,7 @@
 // detail/concurrency_hint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/conditionally_enabled_event.hpp b/boost/asio/detail/conditionally_enabled_event.hpp
index f3025365545a5326526a3a8bc0b6f252463eff27..f6c390971347551ca8b635070e5002756e9bfa2c 100644
--- a/boost/asio/detail/conditionally_enabled_event.hpp
+++ b/boost/asio/detail/conditionally_enabled_event.hpp
@@ -2,7 +2,7 @@
 // detail/conditionally_enabled_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/conditionally_enabled_mutex.hpp b/boost/asio/detail/conditionally_enabled_mutex.hpp
index fa712dfadd1f3b72b20dd15bb27c64c87c63813a..5a71314debc95034107342e6181695208be78e80 100644
--- a/boost/asio/detail/conditionally_enabled_mutex.hpp
+++ b/boost/asio/detail/conditionally_enabled_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/conditionally_enabled_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/config.hpp b/boost/asio/detail/config.hpp
index aa33a359a6f5f8c51ee578ebbea24d1c7779113e..145a160f6385b42ec5f33a9d1bbf06f4a34eba90 100644
--- a/boost/asio/detail/config.hpp
+++ b/boost/asio/detail/config.hpp
@@ -2,7 +2,7 @@
 // detail/config.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -12,6 +12,7 @@
 #define BOOST_ASIO_DETAIL_CONFIG_HPP
 
 #if defined(BOOST_ASIO_STANDALONE)
+# define BOOST_ASIO_DISABLE_BOOST_ALIGN 1
 # define BOOST_ASIO_DISABLE_BOOST_ARRAY 1
 # define BOOST_ASIO_DISABLE_BOOST_ASSERT 1
 # define BOOST_ASIO_DISABLE_BOOST_BIND 1
@@ -98,8 +99,7 @@
 #   if __has_feature(__cxx_rvalue_references__)
 #    define BOOST_ASIO_HAS_MOVE 1
 #   endif // __has_feature(__cxx_rvalue_references__)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_MOVE 1
@@ -172,8 +172,7 @@
 #   if __has_feature(__cxx_variadic_templates__)
 #    define BOOST_ASIO_HAS_VARIADIC_TEMPLATES 1
 #   endif // __has_feature(__cxx_variadic_templates__)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_VARIADIC_TEMPLATES 1
@@ -197,18 +196,17 @@
 
 // Support deleted functions on compilers known to allow it.
 #if !defined(BOOST_ASIO_DELETED)
-# if defined(__GNUC__)
+# if defined(__clang__)
+#  if __has_feature(__cxx_deleted_functions__)
+#   define BOOST_ASIO_DELETED = delete
+#  endif // __has_feature(__cxx_deleted_functions__)
+# elif defined(__GNUC__)
 #  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
 #   if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #    define BOOST_ASIO_DELETED = delete
 #   endif // (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
 # endif // defined(__GNUC__)
-# if defined(__clang__)
-#  if __has_feature(__cxx_deleted_functions__)
-#   define BOOST_ASIO_DELETED = delete
-#  endif // __has_feature(__cxx_deleted_functions__)
-# endif // defined(__clang__)
 # if defined(BOOST_ASIO_MSVC)
 #  if (_MSC_VER >= 1900)
 #   define BOOST_ASIO_DELETED = delete
@@ -226,8 +224,7 @@
 #   if __has_feature(__cxx_constexpr__)
 #    define BOOST_ASIO_HAS_CONSTEXPR 1
 #   endif // __has_feature(__cxx_constexpr__)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_CONSTEXPR 1
@@ -333,6 +330,25 @@
 # endif // defined(BOOST_ASIO_HAS_NOEXCEPT)
 #endif // !defined(BOOST_ASIO_NOEXCEPT_IF)
 
+// Support noexcept on function types on compilers known to allow it.
+#if !defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+# if !defined(BOOST_ASIO_DISABLE_NOEXCEPT_FUNCTION_TYPE)
+#  if defined(__clang__)
+#   if (__cplusplus >= 202002)
+#    define BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE 1
+#   endif // (__cplusplus >= 202002)
+#  elif defined(__GNUC__)
+#   if (__cplusplus >= 202002)
+#    define BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE 1
+#   endif // (__cplusplus >= 202002)
+#  elif defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1900 && _MSVC_LANG >= 202002)
+#    define BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE 1
+#   endif // (_MSC_VER >= 1900 && _MSVC_LANG >= 202002)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_NOEXCEPT_FUNCTION_TYPE)
+#endif // !defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
 // Support automatic type deduction on compilers known to support it.
 #if !defined(BOOST_ASIO_HAS_DECLTYPE)
 # if !defined(BOOST_ASIO_DISABLE_DECLTYPE)
@@ -340,8 +356,7 @@
 #   if __has_feature(__cxx_decltype__)
 #    define BOOST_ASIO_HAS_DECLTYPE 1
 #   endif // __has_feature(__cxx_decltype__)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_DECLTYPE 1
@@ -363,8 +378,7 @@
 #   if __has_feature(__cxx_alias_templates__)
 #    define BOOST_ASIO_HAS_ALIAS_TEMPLATES 1
 #   endif // __has_feature(__cxx_alias_templates__)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_ALIAS_TEMPLATES 1
@@ -409,6 +423,19 @@
 # endif // !defined(BOOST_ASIO_DISABLE_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS)
 #endif // !defined(BOOST_ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS)
 
+// Support enum classes on compilers known to allow them.
+#if !defined(BOOST_ASIO_HAS_ENUM_CLASS)
+# if !defined(BOOST_ASIO_DISABLE_ENUM_CLASS)
+#  if (__cplusplus >= 201103)
+#   define BOOST_ASIO_HAS_ENUM_CLASS 1
+#  elif defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1900 && _MSVC_LANG >= 201103)
+#    define BOOST_ASIO_HAS_ENUM_CLASS 1
+#   endif // (_MSC_VER >= 1900 && _MSVC_LANG >= 201103)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_ENUM_CLASS)
+#endif // !defined(BOOST_ASIO_HAS_ENUM_CLASS)
+
 // Support concepts on compilers known to allow them.
 #if !defined(BOOST_ASIO_HAS_CONCEPTS)
 # if !defined(BOOST_ASIO_DISABLE_CONCEPTS)
@@ -432,8 +459,7 @@
 #     define BOOST_ASIO_HAS_VARIABLE_TEMPLATES 1
 #    endif // __has_feature(__cxx_variable_templates__)
 #   endif // (__cplusplus >= 201402)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__) && !defined(__INTEL_COMPILER)
+#  elif defined(__GNUC__) && !defined(__INTEL_COMPILER)
 #   if (__GNUC__ >= 6)
 #    if (__cplusplus >= 201402)
 #     define BOOST_ASIO_HAS_VARIABLE_TEMPLATES 1
@@ -457,8 +483,7 @@
 #     define BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES 1
 #    endif // __has_feature(__cxx_variable_templates__)
 #   endif // (__cplusplus >= 201703)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 8) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 8)
 #    if (__cplusplus >= 201402)
 #     define BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES 1
@@ -480,8 +505,7 @@
 #   if (__cplusplus >= 201402)
 #    define BOOST_ASIO_HAS_CONSTANT_EXPRESSION_SFINAE 1
 #   endif // (__cplusplus >= 201402)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__) && !defined(__INTEL_COMPILER)
+#  elif defined(__GNUC__) && !defined(__INTEL_COMPILER)
 #   if (__GNUC__ >= 7)
 #    if (__cplusplus >= 201402)
 #     define BOOST_ASIO_HAS_CONSTANT_EXPRESSION_SFINAE 1
@@ -503,7 +527,11 @@
 #   if (__cplusplus >= 201103)
 #    define BOOST_ASIO_HAS_WORKING_EXPRESSION_SFINAE 1
 #   endif // (__cplusplus >= 201103)
-#  endif // !defined(BOOST_ASIO_MSVC) && !defined(__INTEL_COMPILER)
+#  elif defined(BOOST_ASIO_MSVC) && (_MSC_VER >= 1929)
+#   if (_MSVC_LANG >= 202000)
+#    define BOOST_ASIO_HAS_WORKING_EXPRESSION_SFINAE 1
+#   endif // (_MSVC_LANG >= 202000)
+#  endif // defined(BOOST_ASIO_MSVC) && (_MSC_VER >= 1929)
 # endif // !defined(BOOST_ASIO_DISABLE_WORKING_EXPRESSION_SFINAE)
 #endif // !defined(BOOST_ASIO_HAS_WORKING_EXPRESSION_SFINAE)
 
@@ -514,8 +542,7 @@
 #   if __has_feature(__cxx_reference_qualified_functions__)
 #    define BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS 1
 #   endif // __has_feature(__cxx_reference_qualified_functions__)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS 1
@@ -545,6 +572,56 @@
 # endif // !defined(BOOST_ASIO_RVALUE_REF_QUAL)
 #endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
 
+// Support for the alignof operator.
+#if !defined(BOOST_ASIO_HAS_ALIGNOF)
+# if !defined(BOOST_ASIO_DISABLE_ALIGNOF)
+#  if (__cplusplus >= 201103)
+#   define BOOST_ASIO_HAS_ALIGNOF 1
+#  endif // (__cplusplus >= 201103)
+# endif // !defined(BOOST_ASIO_DISABLE_ALIGNOF)
+#endif // !defined(BOOST_ASIO_HAS_ALIGNOF)
+
+#if defined(BOOST_ASIO_HAS_ALIGNOF)
+# define BOOST_ASIO_ALIGNOF(T) alignof(T)
+# if defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
+#  define BOOST_ASIO_DEFAULT_ALIGN __STDCPP_DEFAULT_NEW_ALIGNMENT__
+# elif defined(__GNUC__)
+#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) || (__GNUC__ > 4)
+#   define BOOST_ASIO_DEFAULT_ALIGN alignof(std::max_align_t)
+#  else // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) || (__GNUC__ > 4)
+#   define BOOST_ASIO_DEFAULT_ALIGN alignof(max_align_t)
+#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) || (__GNUC__ > 4)
+# else // defined(__GNUC__)
+#  define BOOST_ASIO_DEFAULT_ALIGN alignof(std::max_align_t)
+# endif // defined(__GNUC__)
+#else // defined(BOOST_ASIO_HAS_ALIGNOF)
+# define BOOST_ASIO_ALIGNOF(T) 1
+# define BOOST_ASIO_DEFAULT_ALIGN 1
+#endif // defined(BOOST_ASIO_HAS_ALIGNOF)
+
+// Standard library support for aligned allocation.
+#if !defined(BOOST_ASIO_HAS_STD_ALIGNED_ALLOC)
+# if !defined(BOOST_ASIO_DISABLE_STD_ALIGNED_ALLOC)
+#  if (__cplusplus >= 201703)
+#   if defined(__clang__)
+#    if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#     if (_LIBCPP_STD_VER > 14) && defined(_LIBCPP_HAS_ALIGNED_ALLOC) \
+        && !defined(_LIBCPP_MSVCRT) && !defined(__MINGW32__)
+#      define BOOST_ASIO_HAS_STD_ALIGNED_ALLOC 1
+#     endif // (_LIBCPP_STD_VER > 14) && defined(_LIBCPP_HAS_ALIGNED_ALLOC)
+            //   && !defined(_LIBCPP_MSVCRT) && !defined(__MINGW32__)
+#    elif defined(_GLIBCXX_HAVE_ALIGNED_ALLOC)
+#     define BOOST_ASIO_HAS_STD_ALIGNED_ALLOC 1
+#    endif // defined(_GLIBCXX_HAVE_ALIGNED_ALLOC)
+#   elif defined(__GNUC__)
+#    if defined(_GLIBCXX_HAVE_ALIGNED_ALLOC)
+#     define BOOST_ASIO_HAS_STD_ALIGNED_ALLOC 1
+#    endif // defined(_GLIBCXX_HAVE_ALIGNED_ALLOC)
+#   endif // defined(__GNUC__)
+#  endif // (__cplusplus >= 201703)
+# endif // !defined(BOOST_ASIO_DISABLE_STD_ALIGNED_ALLOC)
+#endif // !defined(BOOST_ASIO_HAS_STD_ALIGNED_ALLOC)
+
 // Standard library support for system errors.
 # if !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR)
 #  if defined(__clang__)
@@ -555,8 +632,7 @@
 #     define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1
 #    endif // __has_include(<system_error>)
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1
@@ -605,8 +681,7 @@
 #     define BOOST_ASIO_HAS_STD_ARRAY 1
 #    endif // __has_include(<array>)
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_ARRAY 1
@@ -630,8 +705,7 @@
 #   elif (__cplusplus >= 201103)
 #    define BOOST_ASIO_HAS_STD_SHARED_PTR 1
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_SHARED_PTR 1
@@ -655,8 +729,7 @@
 #   elif (__cplusplus >= 201103)
 #    define BOOST_ASIO_HAS_STD_ALLOCATOR_ARG 1
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_ALLOCATOR_ARG 1
@@ -688,8 +761,7 @@
 #     endif // __has_include(<atomic>)
 #    endif // (__clang_major__ >= 10)
 #   endif // defined(__apple_build_version__) && defined(_LIBCPP_VERSION)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_ATOMIC 1
@@ -717,8 +789,7 @@
 #     define BOOST_ASIO_HAS_STD_CHRONO 1
 #    endif // __has_include(<chrono>)
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_CHRONO 1
@@ -770,8 +841,7 @@
 #   elif (__cplusplus >= 201103)
 #    define BOOST_ASIO_HAS_STD_ADDRESSOF 1
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_ADDRESSOF 1
@@ -795,8 +865,7 @@
 #   elif (__cplusplus >= 201103)
 #    define BOOST_ASIO_HAS_STD_FUNCTION 1
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_FUNCTION 1
@@ -811,6 +880,30 @@
 # endif // !defined(BOOST_ASIO_DISABLE_STD_FUNCTION)
 #endif // !defined(BOOST_ASIO_HAS_STD_FUNCTION)
 
+// Standard library support for the reference_wrapper class.
+#if !defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER)
+# if !defined(BOOST_ASIO_DISABLE_STD_REFERENCE_WRAPPER)
+#  if defined(__clang__)
+#   if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#    define BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER 1
+#   elif (__cplusplus >= 201103)
+#    define BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER 1
+#   endif // (__cplusplus >= 201103)
+#  elif defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER 1
+#    endif // (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_STD_REFERENCE_WRAPPER)
+#endif // !defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER)
+
 // Standard library support for type traits.
 #if !defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS)
 # if !defined(BOOST_ASIO_DISABLE_STD_TYPE_TRAITS)
@@ -822,8 +915,7 @@
 #     define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1
 #    endif // __has_include(<type_traits>)
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1
@@ -893,8 +985,7 @@
 #   elif (__cplusplus >= 201103)
 #    define BOOST_ASIO_HAS_CSTDINT 1
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_CSTDINT 1
@@ -920,8 +1011,7 @@
 #     define BOOST_ASIO_HAS_STD_THREAD 1
 #    endif // __has_include(<thread>)
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_THREAD 1
@@ -947,8 +1037,7 @@
 #     define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1
 #    endif // __has_include(<mutex>)
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1
@@ -974,8 +1063,7 @@
 #     define BOOST_ASIO_HAS_STD_CALL_ONCE 1
 #    endif // __has_include(<mutex>)
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_CALL_ONCE 1
@@ -1001,8 +1089,7 @@
 #     define BOOST_ASIO_HAS_STD_FUTURE 1
 #    endif // __has_include(<future>)
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_FUTURE 1
@@ -1067,8 +1154,7 @@
 #     endif // __has_include(<experimental/string_view>)
 #    endif // (__cplusplus >= 201402)
 #   endif // // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201402)
 #     define BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW 1
@@ -1092,14 +1178,17 @@
 // Standard library support for iostream move construction and assignment.
 #if !defined(BOOST_ASIO_HAS_STD_IOSTREAM_MOVE)
 # if !defined(BOOST_ASIO_DISABLE_STD_IOSTREAM_MOVE)
-#  if defined(__GNUC__)
+#  if defined(__clang__)
+#   if (__cplusplus >= 201103)
+#    define BOOST_ASIO_HAS_STD_IOSTREAM_MOVE 1
+#   endif // (__cplusplus >= 201103)
+#  elif defined(__GNUC__)
 #   if (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_IOSTREAM_MOVE 1
 #    endif // (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #   endif // (__GNUC__ > 4)
-#  endif // defined(__GNUC__)
-#  if defined(BOOST_ASIO_MSVC)
+#  elif defined(BOOST_ASIO_MSVC)
 #   if (_MSC_VER >= 1700)
 #    define BOOST_ASIO_HAS_STD_IOSTREAM_MOVE 1
 #   endif // (_MSC_VER >= 1700)
@@ -1115,6 +1204,13 @@
 #    define BOOST_ASIO_HAS_STD_INVOKE_RESULT 1
 #   endif // (_MSC_VER >= 1911 && _MSVC_LANG >= 201703)
 #  endif // defined(BOOST_ASIO_MSVC)
+#  if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#   if (_LIBCPP_VERSION >= 13000)
+#    if (__cplusplus >= 202002)
+#     define BOOST_ASIO_HAS_STD_INVOKE_RESULT 1
+#    endif // (__cplusplus >= 202002)
+#   endif // (_LIBCPP_VERSION >= 13000)
+#  endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
 # endif // !defined(BOOST_ASIO_DISABLE_STD_INVOKE_RESULT)
 #endif // !defined(BOOST_ASIO_HAS_STD_INVOKE_RESULT)
 
@@ -1382,6 +1478,13 @@
 # endif // !defined(BOOST_ASIO_HAS_TIMERFD)
 #endif // defined(__linux__)
 
+// Linux: io_uring is used instead of epoll.
+#if !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# if !defined(BOOST_ASIO_HAS_EPOLL) && defined(BOOST_ASIO_HAS_IO_URING)
+#  define BOOST_ASIO_HAS_IO_URING_AS_DEFAULT 1
+# endif // !defined(BOOST_ASIO_HAS_EPOLL) && defined(BOOST_ASIO_HAS_IO_URING)
+#endif // !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+
 // Mac OS X, FreeBSD, NetBSD, OpenBSD: kqueue.
 #if (defined(__MACH__) && defined(__APPLE__)) \
   || defined(__FreeBSD__) \
@@ -1483,6 +1586,34 @@
 # endif // !defined(BOOST_ASIO_DISABLE_LOCAL_SOCKETS)
 #endif // !defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)
 
+// Files.
+#if !defined(BOOST_ASIO_HAS_FILE)
+# if !defined(BOOST_ASIO_DISABLE_FILE)
+#  if defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
+#   define BOOST_ASIO_HAS_FILE 1
+#  elif defined(BOOST_ASIO_HAS_IO_URING)
+#   define BOOST_ASIO_HAS_FILE 1
+#  endif // defined(BOOST_ASIO_HAS_IO_URING)
+# endif // !defined(BOOST_ASIO_DISABLE_FILE)
+#endif // !defined(BOOST_ASIO_HAS_FILE)
+
+// Pipes.
+#if !defined(BOOST_ASIO_HAS_PIPE)
+# if defined(BOOST_ASIO_HAS_IOCP) \
+  || !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
+#  if !defined(__SYMBIAN32__)
+#   if !defined(BOOST_ASIO_DISABLE_PIPE)
+#    define BOOST_ASIO_HAS_PIPE 1
+#   endif // !defined(BOOST_ASIO_DISABLE_PIPE)
+#  endif // !defined(__SYMBIAN32__)
+# endif // defined(BOOST_ASIO_HAS_IOCP)
+        //   || !defined(BOOST_ASIO_WINDOWS)
+        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+        //   && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_HAS_PIPE)
+
 // Can use sigaction() instead of signal().
 #if !defined(BOOST_ASIO_HAS_SIGACTION)
 # if !defined(BOOST_ASIO_DISABLE_SIGACTION)
@@ -1600,6 +1731,15 @@
 # endif // !defined(BOOST_ASIO_DISABLE_BOOST_STATIC_CONSTANT)
 #endif // !defined(BOOST_ASIO_STATIC_CONSTANT)
 
+// Boost align library.
+#if !defined(BOOST_ASIO_HAS_BOOST_ALIGN)
+# if !defined(BOOST_ASIO_DISABLE_BOOST_ALIGN)
+#  if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && (BOOST_VERSION >= 105600)
+#   define BOOST_ASIO_HAS_BOOST_ALIGN 1
+#  endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && (BOOST_VERSION >= 105600)
+# endif // !defined(BOOST_ASIO_DISABLE_BOOST_ALIGN)
+#endif // !defined(BOOST_ASIO_HAS_BOOST_ALIGN)
+
 // Boost array library.
 #if !defined(BOOST_ASIO_HAS_BOOST_ARRAY)
 # if !defined(BOOST_ASIO_DISABLE_BOOST_ARRAY)
@@ -1754,15 +1894,14 @@
 #if !defined(BOOST_ASIO_HAS_CO_AWAIT)
 # if !defined(BOOST_ASIO_DISABLE_CO_AWAIT)
 #  if defined(BOOST_ASIO_MSVC)
-#   if (_MSC_VER >= 1928) && (_MSVC_LANG >= 201705)
+#   if (_MSC_VER >= 1928) && (_MSVC_LANG >= 201705) && !defined(__clang__)
 #    define BOOST_ASIO_HAS_CO_AWAIT 1
 #   elif (_MSC_FULL_VER >= 190023506)
 #    if defined(_RESUMABLE_FUNCTIONS_SUPPORTED)
 #     define BOOST_ASIO_HAS_CO_AWAIT 1
 #    endif // defined(_RESUMABLE_FUNCTIONS_SUPPORTED)
 #   endif // (_MSC_FULL_VER >= 190023506)
-#  endif // defined(BOOST_ASIO_MSVC)
-#  if defined(__clang__)
+#  elif defined(__clang__)
 #   if (__cplusplus >= 201703) && (__cpp_coroutines >= 201703)
 #    if __has_include(<experimental/coroutine>)
 #     define BOOST_ASIO_HAS_CO_AWAIT 1
@@ -1830,8 +1969,7 @@
 #   elif (__cplusplus >= 201103)
 #    define BOOST_ASIO_HAS_STD_HASH 1
 #   endif // (__cplusplus >= 201103)
-#  endif // defined(__clang__)
-#  if defined(__GNUC__)
+#  elif defined(__GNUC__)
 #   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
 #    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_HAS_STD_HASH 1
diff --git a/boost/asio/detail/consuming_buffers.hpp b/boost/asio/detail/consuming_buffers.hpp
index 3a091808d0848bfa64446f0ec11c30d812eb1fc0..8c2bd640c91a15acb2e7857a38ee5d5349b971b6 100644
--- a/boost/asio/detail/consuming_buffers.hpp
+++ b/boost/asio/detail/consuming_buffers.hpp
@@ -2,7 +2,7 @@
 // detail/consuming_buffers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,6 +20,7 @@
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/limits.hpp>
+#include <boost/asio/registered_buffer.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -270,6 +271,42 @@ public:
 
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
+template <>
+class consuming_buffers<mutable_buffer,
+    mutable_registered_buffer, const mutable_buffer*>
+  : public consuming_single_buffer<mutable_registered_buffer>
+{
+public:
+  explicit consuming_buffers(const mutable_registered_buffer& buffer)
+    : consuming_single_buffer<mutable_registered_buffer>(buffer)
+  {
+  }
+};
+
+template <>
+class consuming_buffers<const_buffer,
+    mutable_registered_buffer, const mutable_buffer*>
+  : public consuming_single_buffer<mutable_registered_buffer>
+{
+public:
+  explicit consuming_buffers(const mutable_registered_buffer& buffer)
+    : consuming_single_buffer<mutable_registered_buffer>(buffer)
+  {
+  }
+};
+
+template <>
+class consuming_buffers<const_buffer,
+    const_registered_buffer, const const_buffer*>
+  : public consuming_single_buffer<const_registered_buffer>
+{
+public:
+  explicit consuming_buffers(const const_registered_buffer& buffer)
+    : consuming_single_buffer<const_registered_buffer>(buffer)
+  {
+  }
+};
+
 template <typename Buffer, typename Elem>
 class consuming_buffers<Buffer, boost::array<Elem, 2>,
     typename boost::array<Elem, 2>::const_iterator>
diff --git a/boost/asio/detail/cstddef.hpp b/boost/asio/detail/cstddef.hpp
index 0d16e3c7b5212009955ba6e1d0200b7a9cc0b132..9a3b00a85627ed0674b2e260c2faa4cd51bcc264 100644
--- a/boost/asio/detail/cstddef.hpp
+++ b/boost/asio/detail/cstddef.hpp
@@ -2,7 +2,7 @@
 // detail/cstddef.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/cstdint.hpp b/boost/asio/detail/cstdint.hpp
index f309bf8b42f3a824d47df76fb1ea74d5269257cf..c3ef46e525ef8a1b5cc4a71ff4ab3baa847e96d1 100644
--- a/boost/asio/detail/cstdint.hpp
+++ b/boost/asio/detail/cstdint.hpp
@@ -2,7 +2,7 @@
 // detail/cstdint.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -39,6 +39,7 @@ using std::int64_t;
 using std::int_least64_t;
 using std::uint64_t;
 using std::uint_least64_t;
+using std::uintptr_t;
 using std::uintmax_t;
 #else // defined(BOOST_ASIO_HAS_CSTDINT)
 using boost::int16_t;
@@ -53,6 +54,7 @@ using boost::int64_t;
 using boost::int_least64_t;
 using boost::uint64_t;
 using boost::uint_least64_t;
+using boost::uintptr_t;
 using boost::uintmax_t;
 #endif // defined(BOOST_ASIO_HAS_CSTDINT)
 
diff --git a/boost/asio/detail/date_time_fwd.hpp b/boost/asio/detail/date_time_fwd.hpp
index b32ab3b55c9d558369ba025f008e17a3e1ad804b..2d391b5418141ee15673a90fc2e6c3e58fa11955 100644
--- a/boost/asio/detail/date_time_fwd.hpp
+++ b/boost/asio/detail/date_time_fwd.hpp
@@ -2,7 +2,7 @@
 // detail/date_time_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/deadline_timer_service.hpp b/boost/asio/detail/deadline_timer_service.hpp
index 78087a720418c68f908d079fb7c5b6118a11a851..1202c1431b09e1243559fcc66099db75ae5b38f1 100644
--- a/boost/asio/detail/deadline_timer_service.hpp
+++ b/boost/asio/detail/deadline_timer_service.hpp
@@ -2,7 +2,7 @@
 // detail/deadline_timer_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,8 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/cancellation_type.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/execution_context.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
@@ -246,12 +248,22 @@ public:
   void async_wait(implementation_type& impl,
       Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef wait_handler<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<op_cancellation>(this, &impl.timer_data);
+    }
+
     impl.might_have_pending_waits = true;
 
     BOOST_ASIO_HANDLER_CREATION((scheduler_.context(),
@@ -281,6 +293,34 @@ private:
 #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
   }
 
+  // Helper class used to implement per-operation cancellation.
+  class op_cancellation
+  {
+  public:
+    op_cancellation(deadline_timer_service* s,
+        typename timer_queue<Time_Traits>::per_timer_data* p)
+      : service_(s),
+        timer_data_(p)
+    {
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+      if (!!(type &
+            (cancellation_type::terminal
+              | cancellation_type::partial
+              | cancellation_type::total)))
+      {
+        service_->scheduler_.cancel_timer_by_key(
+            service_->timer_queue_, timer_data_, this);
+      }
+    }
+
+  private:
+    deadline_timer_service* service_;
+    typename timer_queue<Time_Traits>::per_timer_data* timer_data_;
+  };
+
   // The queue of timers.
   timer_queue<Time_Traits> timer_queue_;
 
diff --git a/boost/asio/detail/dependent_type.hpp b/boost/asio/detail/dependent_type.hpp
index ec5ab7254488a34f1e446fee7d656d6dd02a0261..58aa27adf07c373080078306a5834122d75c1750 100644
--- a/boost/asio/detail/dependent_type.hpp
+++ b/boost/asio/detail/dependent_type.hpp
@@ -2,7 +2,7 @@
 // detail/dependent_type.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/descriptor_ops.hpp b/boost/asio/detail/descriptor_ops.hpp
index e1981b346e54560f959edfd1cd1995b3ef047a9b..ca9d08555289f14509fbd61a6d61a38fa201edb2 100644
--- a/boost/asio/detail/descriptor_ops.hpp
+++ b/boost/asio/detail/descriptor_ops.hpp
@@ -2,7 +2,7 @@
 // detail/descriptor_ops.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -24,6 +24,7 @@
 #include <cstddef>
 #include <boost/asio/error.hpp>
 #include <boost/system/error_code.hpp>
+#include <boost/asio/detail/cstdint.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -68,6 +69,9 @@ inline void get_last_error(
 BOOST_ASIO_DECL int open(const char* path, int flags,
     boost::system::error_code& ec);
 
+BOOST_ASIO_DECL int open(const char* path, int flags, unsigned mode,
+    boost::system::error_code& ec);
+
 BOOST_ASIO_DECL int close(int d, state_type& state,
     boost::system::error_code& ec);
 
@@ -106,6 +110,42 @@ BOOST_ASIO_DECL bool non_blocking_write1(int d,
     const void* data, std::size_t size,
     boost::system::error_code& ec, std::size_t& bytes_transferred);
 
+#if defined(BOOST_ASIO_HAS_FILE)
+
+BOOST_ASIO_DECL std::size_t sync_read_at(int d, state_type state,
+    uint64_t offset, buf* bufs, std::size_t count, bool all_empty,
+    boost::system::error_code& ec);
+
+BOOST_ASIO_DECL std::size_t sync_read_at1(int d, state_type state,
+    uint64_t offset, void* data, std::size_t size,
+    boost::system::error_code& ec);
+
+BOOST_ASIO_DECL bool non_blocking_read_at(int d, uint64_t offset,
+    buf* bufs, std::size_t count, boost::system::error_code& ec,
+    std::size_t& bytes_transferred);
+
+BOOST_ASIO_DECL bool non_blocking_read_at1(int d, uint64_t offset,
+    void* data, std::size_t size, boost::system::error_code& ec,
+    std::size_t& bytes_transferred);
+
+BOOST_ASIO_DECL std::size_t sync_write_at(int d, state_type state,
+    uint64_t offset, const buf* bufs, std::size_t count, bool all_empty,
+    boost::system::error_code& ec);
+
+BOOST_ASIO_DECL std::size_t sync_write_at1(int d, state_type state,
+    uint64_t offset, const void* data, std::size_t size,
+    boost::system::error_code& ec);
+
+BOOST_ASIO_DECL bool non_blocking_write_at(int d,
+    uint64_t offset, const buf* bufs, std::size_t count,
+    boost::system::error_code& ec, std::size_t& bytes_transferred);
+
+BOOST_ASIO_DECL bool non_blocking_write_at1(int d,
+    uint64_t offset, const void* data, std::size_t size,
+    boost::system::error_code& ec, std::size_t& bytes_transferred);
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+
 BOOST_ASIO_DECL int ioctl(int d, state_type& state, long cmd,
     ioctl_arg_type* arg, boost::system::error_code& ec);
 
diff --git a/boost/asio/detail/descriptor_read_op.hpp b/boost/asio/detail/descriptor_read_op.hpp
index 9d0805bbf51b6aae780c3676589e67f207f811cb..a08ed4dc9512268e70b7faafecceac9f8e6761ff 100644
--- a/boost/asio/detail/descriptor_read_op.hpp
+++ b/boost/asio/detail/descriptor_read_op.hpp
@@ -2,7 +2,7 @@
 // detail/descriptor_read_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/descriptor_write_op.hpp b/boost/asio/detail/descriptor_write_op.hpp
index b06390932126c629354ed220ccadd262d14446ba..09188866eb4da0fa1b62d6dea135859ab36624b4 100644
--- a/boost/asio/detail/descriptor_write_op.hpp
+++ b/boost/asio/detail/descriptor_write_op.hpp
@@ -2,7 +2,7 @@
 // detail/descriptor_write_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/dev_poll_reactor.hpp b/boost/asio/detail/dev_poll_reactor.hpp
index 6f775e59e6309b98baf99d3a4731d64aa3519a8b..f6a2fae4a633042d3bf79dfab6e30709f6274cae 100644
--- a/boost/asio/detail/dev_poll_reactor.hpp
+++ b/boost/asio/detail/dev_poll_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/dev_poll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -28,6 +28,7 @@
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/reactor_op_queue.hpp>
+#include <boost/asio/detail/scheduler_task.hpp>
 #include <boost/asio/detail/select_interrupter.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
@@ -42,7 +43,8 @@ namespace asio {
 namespace detail {
 
 class dev_poll_reactor
-  : public execution_context_service_base<dev_poll_reactor>
+  : public execution_context_service_base<dev_poll_reactor>,
+    public scheduler_task
 {
 public:
   enum op_types { read_op = 0, write_op = 1,
@@ -85,10 +87,7 @@ public:
       per_descriptor_data& source_descriptor_data);
 
   // Post a reactor operation for immediate completion.
-  void post_immediate_completion(reactor_op* op, bool is_continuation)
-  {
-    scheduler_.post_immediate_completion(op, is_continuation);
-  }
+  void post_immediate_completion(reactor_op* op, bool is_continuation);
 
   // Start a new operation. The reactor operation will be performed when the
   // given descriptor is flagged as ready, or an error has occurred.
@@ -101,6 +100,13 @@ public:
   // operation_aborted error.
   BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&);
 
+  // Cancel all operations associated with the given descriptor and key. The
+  // handlers associated with the descriptor will be invoked with the
+  // operation_aborted error.
+  BOOST_ASIO_DECL void cancel_ops_by_key(socket_type descriptor,
+      per_descriptor_data& descriptor_data,
+      int op_type, void* cancellation_key);
+
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor. The reactor resources associated with
   // the descriptor must be released by calling cleanup_descriptor_data.
@@ -139,6 +145,12 @@ public:
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Cancel the timer operations associated with the given key.
+  template <typename Time_Traits>
+  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data* timer,
+      void* cancellation_key);
+
   // Move the timer operations associated with the given timer.
   template <typename Time_Traits>
   void move_timer(timer_queue<Time_Traits>& queue,
diff --git a/boost/asio/detail/epoll_reactor.hpp b/boost/asio/detail/epoll_reactor.hpp
index 61da05271752b4847bba6ff8a66ee06192cc3de6..e2de3e7f3c79bf1619763818ebca4a6ea7080454 100644
--- a/boost/asio/detail/epoll_reactor.hpp
+++ b/boost/asio/detail/epoll_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/epoll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -25,6 +25,7 @@
 #include <boost/asio/detail/object_pool.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
+#include <boost/asio/detail/scheduler_task.hpp>
 #include <boost/asio/detail/select_interrupter.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
@@ -43,7 +44,8 @@ namespace asio {
 namespace detail {
 
 class epoll_reactor
-  : public execution_context_service_base<epoll_reactor>
+  : public execution_context_service_base<epoll_reactor>,
+    public scheduler_task
 {
 private:
   // The mutex type used by this reactor.
@@ -115,10 +117,7 @@ public:
       per_descriptor_data& source_descriptor_data);
 
   // Post a reactor operation for immediate completion.
-  void post_immediate_completion(reactor_op* op, bool is_continuation)
-  {
-    scheduler_.post_immediate_completion(op, is_continuation);
-  }
+  void post_immediate_completion(operation* op, bool is_continuation);
 
   // Start a new operation. The reactor operation will be performed when the
   // given descriptor is flagged as ready, or an error has occurred.
@@ -132,6 +131,13 @@ public:
   BOOST_ASIO_DECL void cancel_ops(socket_type descriptor,
       per_descriptor_data& descriptor_data);
 
+  // Cancel all operations associated with the given descriptor and key. The
+  // handlers associated with the descriptor will be invoked with the
+  // operation_aborted error.
+  BOOST_ASIO_DECL void cancel_ops_by_key(socket_type descriptor,
+      per_descriptor_data& descriptor_data,
+      int op_type, void* cancellation_key);
+
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor. The reactor resources associated with
   // the descriptor must be released by calling cleanup_descriptor_data.
@@ -171,6 +177,12 @@ public:
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Cancel the timer operations associated with the given key.
+  template <typename Time_Traits>
+  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data* timer,
+      void* cancellation_key);
+
   // Move the timer operations associated with the given timer.
   template <typename Time_Traits>
   void move_timer(timer_queue<Time_Traits>& queue,
diff --git a/boost/asio/detail/event.hpp b/boost/asio/detail/event.hpp
index 02049e359115cdeb4a5a3a6f81cea306e63e1ac7..f4855f26c6af1ba0bc5622d17381a8ef7459b04f 100644
--- a/boost/asio/detail/event.hpp
+++ b/boost/asio/detail/event.hpp
@@ -2,7 +2,7 @@
 // detail/event.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/eventfd_select_interrupter.hpp b/boost/asio/detail/eventfd_select_interrupter.hpp
index 7f18389d6e1593d7f0b94c065adcc5731ced4dac..b1c02b8aa64947228b3fe7eb6298e92cb4605be9 100644
--- a/boost/asio/detail/eventfd_select_interrupter.hpp
+++ b/boost/asio/detail/eventfd_select_interrupter.hpp
@@ -2,7 +2,7 @@
 // detail/eventfd_select_interrupter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Roelof Naude (roelof.naude at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/detail/executor_function.hpp b/boost/asio/detail/executor_function.hpp
index bf6c9c1063943af802790b6d809e7565a2b3168a..8dfa6b4a259844cb70bf2335677973ff429cb0c0 100644
--- a/boost/asio/detail/executor_function.hpp
+++ b/boost/asio/detail/executor_function.hpp
@@ -2,7 +2,7 @@
 // detail/executor_function.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/executor_op.hpp b/boost/asio/detail/executor_op.hpp
index 6a6c9761e10665f4cca117566ccaa298b4526ba1..8679b9eb0b13753794f8ce3cb4e44f50be72d6cd 100644
--- a/boost/asio/detail/executor_op.hpp
+++ b/boost/asio/detail/executor_op.hpp
@@ -2,7 +2,7 @@
 // detail/executor_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/fd_set_adapter.hpp b/boost/asio/detail/fd_set_adapter.hpp
index 2764caf600352f57bf391a5fb02cd8645ffde593..2b0fac99fa7f2504b92a82ac24a112daa223686b 100644
--- a/boost/asio/detail/fd_set_adapter.hpp
+++ b/boost/asio/detail/fd_set_adapter.hpp
@@ -2,7 +2,7 @@
 // detail/fd_set_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/fenced_block.hpp b/boost/asio/detail/fenced_block.hpp
index 462be5e9fab0c0730a77b889b106b06c7b3c6115..bc99ef0ec7278d58ea3b54bf64653733b5ffcebe 100644
--- a/boost/asio/detail/fenced_block.hpp
+++ b/boost/asio/detail/fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/functional.hpp b/boost/asio/detail/functional.hpp
index e2996f72118048d746ef5e51aecf48a7c2266c2e..833f659a70386cd741b38edd25ec277134255a08 100644
--- a/boost/asio/detail/functional.hpp
+++ b/boost/asio/detail/functional.hpp
@@ -2,7 +2,7 @@
 // detail/functional.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -34,6 +34,12 @@ using boost::function;
 #endif // defined(BOOST_ASIO_HAS_STD_FUNCTION)
 
 } // namespace detail
+
+#if defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER)
+using std::ref;
+using std::reference_wrapper;
+#endif // defined(BOOST_ASIO_HAS_STD_REFERENCE_WRAPPER)
+
 } // namespace asio
 } // namespace boost
 
diff --git a/boost/asio/detail/future.hpp b/boost/asio/detail/future.hpp
index ac3d33f6dba1d9e1674f34f11599b7253e0a20da..b8a3750acefa282090878980290d1f09c9af8e4c 100644
--- a/boost/asio/detail/future.hpp
+++ b/boost/asio/detail/future.hpp
@@ -2,7 +2,7 @@
 // detail/future.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/gcc_arm_fenced_block.hpp b/boost/asio/detail/gcc_arm_fenced_block.hpp
index 256b6aa047e59dcaad87b8879b0ed07d7e3fa99d..f179321d1c1637f3fe5e42d45c0c98de60d24e69 100644
--- a/boost/asio/detail/gcc_arm_fenced_block.hpp
+++ b/boost/asio/detail/gcc_arm_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/gcc_arm_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/gcc_hppa_fenced_block.hpp b/boost/asio/detail/gcc_hppa_fenced_block.hpp
index ef7a7b789eb67a71d2e833bded964b8dd542c553..8b584ac77da63366e785ef9503aa9e89b2bd9477 100644
--- a/boost/asio/detail/gcc_hppa_fenced_block.hpp
+++ b/boost/asio/detail/gcc_hppa_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/gcc_hppa_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/gcc_sync_fenced_block.hpp b/boost/asio/detail/gcc_sync_fenced_block.hpp
index 16f87f6092c986bf0a3ed513d4e84596e9b0ee9c..1d7ff427766ef7fd475f31dd1e0c84a567f0eb8b 100644
--- a/boost/asio/detail/gcc_sync_fenced_block.hpp
+++ b/boost/asio/detail/gcc_sync_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/gcc_sync_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/gcc_x86_fenced_block.hpp b/boost/asio/detail/gcc_x86_fenced_block.hpp
index 5b55c7f99f73f6de817bd93832ca641abe9ee88c..72e5721c116ecc35dbabcbf48863842d1a9749b6 100644
--- a/boost/asio/detail/gcc_x86_fenced_block.hpp
+++ b/boost/asio/detail/gcc_x86_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/gcc_x86_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/global.hpp b/boost/asio/detail/global.hpp
index 5fd53cce206859f8cc6a915a665f5ceb5846d435..c515cffc7512a140db731372d31960b4f87c2009 100644
--- a/boost/asio/detail/global.hpp
+++ b/boost/asio/detail/global.hpp
@@ -2,7 +2,7 @@
 // detail/global.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/handler_alloc_helpers.hpp b/boost/asio/detail/handler_alloc_helpers.hpp
index 8dd7ee4a43ea7a77eb7e1973ba8a278064dd1c29..5d127b70fa9df55e1b26a0cdcdf8298058170ec3 100644
--- a/boost/asio/detail/handler_alloc_helpers.hpp
+++ b/boost/asio/detail/handler_alloc_helpers.hpp
@@ -2,7 +2,7 @@
 // detail/handler_alloc_helpers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -51,21 +51,24 @@ inline void error_if_hooks_are_defined(Handler& h)
 #endif // defined(BOOST_ASIO_NO_DEPRECATED)
 
 template <typename Handler>
-inline void* allocate(std::size_t s, Handler& h)
+inline void* allocate(std::size_t s, Handler& h,
+    std::size_t align = BOOST_ASIO_DEFAULT_ALIGN)
 {
 #if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS)
-  return ::operator new(s);
+  return aligned_new(align, s);
 #elif defined(BOOST_ASIO_NO_DEPRECATED)
   // The asio_handler_allocate hook is no longer used to obtain memory.
   (void)&error_if_hooks_are_defined<Handler>;
   (void)h;
-#if !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+# if !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
   return boost::asio::detail::thread_info_base::allocate(
-      boost::asio::detail::thread_context::top_of_thread_call_stack(), s);
-#else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-  return ::operator new(size);
-#endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+      boost::asio::detail::thread_context::top_of_thread_call_stack(),
+      s, align);
+# else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+  return aligned_new(align, s);
+# endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
 #else
+  (void)align;
   using boost::asio::asio_handler_allocate;
   return asio_handler_allocate(s, boost::asio::detail::addressof(h));
 #endif
@@ -75,7 +78,7 @@ template <typename Handler>
 inline void deallocate(void* p, std::size_t s, Handler& h)
 {
 #if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS)
-  ::operator delete(p);
+  aligned_delete(p);
 #elif defined(BOOST_ASIO_NO_DEPRECATED)
   // The asio_handler_allocate hook is no longer used to obtain memory.
   (void)&error_if_hooks_are_defined<Handler>;
@@ -85,7 +88,7 @@ inline void deallocate(void* p, std::size_t s, Handler& h)
       boost::asio::detail::thread_context::top_of_thread_call_stack(), p, s);
 #else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
   (void)s;
-  ::operator delete(p);
+  aligned_delete(p);
 #endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
 #else
   using boost::asio::asio_handler_deallocate;
@@ -125,7 +128,8 @@ public:
   T* allocate(std::size_t n)
   {
     return static_cast<T*>(
-        boost_asio_handler_alloc_helpers::allocate(sizeof(T) * n, handler_));
+        boost_asio_handler_alloc_helpers::allocate(
+          sizeof(T) * n, handler_, BOOST_ASIO_ALIGNOF(T)));
   }
 
   void deallocate(T* p, std::size_t n)
diff --git a/boost/asio/detail/handler_cont_helpers.hpp b/boost/asio/detail/handler_cont_helpers.hpp
index ce0093657b6c4b5887682ffbe7c2b0fc07bd092c..9e763980c6fac799861d4b42c3ecb66c2fe3287e 100644
--- a/boost/asio/detail/handler_cont_helpers.hpp
+++ b/boost/asio/detail/handler_cont_helpers.hpp
@@ -2,7 +2,7 @@
 // detail/handler_cont_helpers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/handler_invoke_helpers.hpp b/boost/asio/detail/handler_invoke_helpers.hpp
index 8c9acce4a58ab6dcb134c8b14d85de93700b4b83..722bfea73c4134dd0af747a090918c0ffbc19c9d 100644
--- a/boost/asio/detail/handler_invoke_helpers.hpp
+++ b/boost/asio/detail/handler_invoke_helpers.hpp
@@ -2,7 +2,7 @@
 // detail/handler_invoke_helpers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/handler_tracking.hpp b/boost/asio/detail/handler_tracking.hpp
index a0cfde52f72ffbf9e388c61156fb8c3d68eaca1d..a1900084aba33c313f0f44c88b3f4d13c2389571 100644
--- a/boost/asio/detail/handler_tracking.hpp
+++ b/boost/asio/detail/handler_tracking.hpp
@@ -2,7 +2,7 @@
 // detail/handler_tracking.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/handler_type_requirements.hpp b/boost/asio/detail/handler_type_requirements.hpp
index c593b86870627a053cfc8bc9e1edb8a19a8508d0..1dfe8d5666aa91b7a4abae675df4a4aa3809f263 100644
--- a/boost/asio/detail/handler_type_requirements.hpp
+++ b/boost/asio/detail/handler_type_requirements.hpp
@@ -2,7 +2,7 @@
 // detail/handler_type_requirements.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -65,7 +65,7 @@ template <typename Handler>
 auto zero_arg_copyable_handler_test(Handler h, void*)
   -> decltype(
     sizeof(Handler(static_cast<const Handler&>(h))),
-    ((h)()),
+    (BOOST_ASIO_MOVE_OR_LVALUE(Handler)(h)()),
     char(0));
 
 template <typename Handler>
@@ -75,7 +75,7 @@ template <typename Handler, typename Arg1>
 auto one_arg_handler_test(Handler h, Arg1* a1)
   -> decltype(
     sizeof(Handler(BOOST_ASIO_MOVE_CAST(Handler)(h))),
-    ((h)(*a1)),
+    (BOOST_ASIO_MOVE_OR_LVALUE(Handler)(h)(*a1)),
     char(0));
 
 template <typename Handler>
@@ -85,7 +85,7 @@ template <typename Handler, typename Arg1, typename Arg2>
 auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
   -> decltype(
     sizeof(Handler(BOOST_ASIO_MOVE_CAST(Handler)(h))),
-    ((h)(*a1, *a2)),
+    (BOOST_ASIO_MOVE_OR_LVALUE(Handler)(h)(*a1, *a2)),
     char(0));
 
 template <typename Handler>
@@ -95,7 +95,8 @@ template <typename Handler, typename Arg1, typename Arg2>
 auto two_arg_move_handler_test(Handler h, Arg1* a1, Arg2* a2)
   -> decltype(
     sizeof(Handler(BOOST_ASIO_MOVE_CAST(Handler)(h))),
-    ((h)(*a1, BOOST_ASIO_MOVE_CAST(Arg2)(*a2))),
+    (BOOST_ASIO_MOVE_OR_LVALUE(Handler)(h)(
+      *a1, BOOST_ASIO_MOVE_CAST(Arg2)(*a2))),
     char(0));
 
 template <typename Handler>
@@ -117,9 +118,11 @@ template <typename T> const T& clvref(T);
 #if defined(BOOST_ASIO_HAS_MOVE)
 template <typename T> T rvref();
 template <typename T> T rvref(T);
+template <typename T> T rorlvref();
 #else // defined(BOOST_ASIO_HAS_MOVE)
 template <typename T> const T& rvref();
 template <typename T> const T& rvref(T);
+template <typename T> T& rorlvref();
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 template <typename T> char argbyv(T);
 
@@ -146,7 +149,7 @@ struct handler_type_requirements
           boost::asio::detail::clvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()(), \
         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 
@@ -171,7 +174,7 @@ struct handler_type_requirements
           boost::asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()( \
             boost::asio::detail::lvref<const boost::system::error_code>(), \
             boost::asio::detail::lvref<const std::size_t>()), \
@@ -198,7 +201,7 @@ struct handler_type_requirements
           boost::asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()( \
             boost::asio::detail::lvref<const boost::system::error_code>(), \
             boost::asio::detail::lvref<const std::size_t>()), \
@@ -224,7 +227,7 @@ struct handler_type_requirements
           boost::asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()( \
             boost::asio::detail::lvref<const boost::system::error_code>()), \
         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
@@ -250,7 +253,7 @@ struct handler_type_requirements
           boost::asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()( \
             boost::asio::detail::lvref<const boost::system::error_code>(), \
             boost::asio::detail::rvref<socket_type>()), \
@@ -276,7 +279,7 @@ struct handler_type_requirements
           boost::asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()( \
             boost::asio::detail::lvref<const boost::system::error_code>()), \
         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
@@ -302,7 +305,7 @@ struct handler_type_requirements
           boost::asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()( \
             boost::asio::detail::lvref<const boost::system::error_code>(), \
             boost::asio::detail::lvref<const endpoint_type>()), \
@@ -329,7 +332,7 @@ struct handler_type_requirements
           boost::asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()( \
             boost::asio::detail::lvref<const boost::system::error_code>(), \
             boost::asio::detail::lvref<const iter_type>()), \
@@ -356,7 +359,7 @@ struct handler_type_requirements
           boost::asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()( \
             boost::asio::detail::lvref<const boost::system::error_code>(), \
             boost::asio::detail::lvref<const range_type>()), \
@@ -382,7 +385,7 @@ struct handler_type_requirements
           boost::asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()( \
             boost::asio::detail::lvref<const boost::system::error_code>()), \
         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
@@ -408,7 +411,7 @@ struct handler_type_requirements
           boost::asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()( \
             boost::asio::detail::lvref<const boost::system::error_code>(), \
             boost::asio::detail::lvref<const int>()), \
@@ -434,7 +437,7 @@ struct handler_type_requirements
           boost::asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()( \
             boost::asio::detail::lvref<const boost::system::error_code>()), \
         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
@@ -460,7 +463,7 @@ struct handler_type_requirements
           boost::asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()( \
           boost::asio::detail::lvref<const boost::system::error_code>(), \
           boost::asio::detail::lvref<const std::size_t>()), \
@@ -486,7 +489,7 @@ struct handler_type_requirements
           boost::asio::detail::rvref< \
             asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref< \
+        boost::asio::detail::rorlvref< \
           asio_true_handler_type>()( \
             boost::asio::detail::lvref<const boost::system::error_code>()), \
         char(0))> BOOST_ASIO_UNUSED_TYPEDEF
diff --git a/boost/asio/detail/handler_work.hpp b/boost/asio/detail/handler_work.hpp
index 83eaa444eb25ff8ddbe033aee0198bfa267a0037..f547d66f72555017bf8be7aad5657e03fe7690a2 100644
--- a/boost/asio/detail/handler_work.hpp
+++ b/boost/asio/detail/handler_work.hpp
@@ -2,7 +2,7 @@
 // detail/handler_work.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -69,8 +69,8 @@ public:
   }
 
   template <typename OtherExecutor>
-  handler_work_base(const Executor& ex,
-      const OtherExecutor&) BOOST_ASIO_NOEXCEPT
+  handler_work_base(bool /*base1_owns_work*/, const Executor& ex,
+      const OtherExecutor& /*candidate*/) BOOST_ASIO_NOEXCEPT
     : executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked))
   {
   }
@@ -130,7 +130,7 @@ public:
     executor_.on_work_started();
   }
 
-  handler_work_base(const Executor& ex,
+  handler_work_base(bool /*base1_owns_work*/, const Executor& ex,
       const Executor& candidate) BOOST_ASIO_NOEXCEPT
     : executor_(ex),
       owns_work_(ex != candidate)
@@ -140,8 +140,8 @@ public:
   }
 
   template <typename OtherExecutor>
-  handler_work_base(const Executor& ex,
-      const OtherExecutor&) BOOST_ASIO_NOEXCEPT
+  handler_work_base(bool /*base1_owns_work*/, const Executor& ex,
+      const OtherExecutor& /*candidate*/) BOOST_ASIO_NOEXCEPT
     : executor_(ex),
       owns_work_(true)
   {
@@ -234,7 +234,7 @@ public:
       executor_.on_work_started();
   }
 
-  handler_work_base(const Executor& ex,
+  handler_work_base(bool /*base1_owns_work*/, const Executor& ex,
       const Executor& candidate) BOOST_ASIO_NOEXCEPT
     : executor_(ex != candidate ? ex : Executor())
   {
@@ -293,14 +293,15 @@ template <
     typename T1, typename T2, typename T3, typename T4, typename T5,
     typename T6, typename T7, typename T8, typename T9,
 #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-    typename IoContext, typename PolymorphicExecutor>
+    typename CandidateExecutor, typename IoContext,
+    typename PolymorphicExecutor>
 class handler_work_base<
 #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
     execution::any_executor<SupportableProperties...>,
 #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
     execution::any_executor<T1, T2, T3, T4, T5, T6, T7, T8, T9>,
 #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-    void, IoContext, PolymorphicExecutor>
+    CandidateExecutor, IoContext, PolymorphicExecutor>
 {
 public:
   typedef
@@ -324,15 +325,18 @@ public:
   {
   }
 
-  handler_work_base(const executor_type& ex,
+  handler_work_base(bool base1_owns_work, const executor_type& ex,
       const executor_type& candidate) BOOST_ASIO_NOEXCEPT
-    : executor_(ex != candidate ? ex : executor_type())
+    : executor_(
+        !base1_owns_work && ex == candidate
+          ? executor_type()
+          : boost::asio::prefer(ex, execution::outstanding_work.tracked))
   {
   }
 
   template <typename OtherExecutor>
-  handler_work_base(const executor_type& ex,
-      const OtherExecutor&) BOOST_ASIO_NOEXCEPT
+  handler_work_base(bool /*base1_owns_work*/, const executor_type& ex,
+      const OtherExecutor& /*candidate*/) BOOST_ASIO_NOEXCEPT
     : executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked))
   {
   }
@@ -368,8 +372,11 @@ private:
 
 #if !defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
 
-template <typename Executor, typename IoContext, typename PolymorphicExecutor>
-class handler_work_base<Executor, void, IoContext, PolymorphicExecutor,
+template <typename Executor, typename CandidateExecutor,
+    typename IoContext, typename PolymorphicExecutor>
+class handler_work_base<
+    Executor, CandidateExecutor,
+    IoContext, PolymorphicExecutor,
     typename enable_if<
       is_same<
         Executor,
@@ -393,15 +400,18 @@ public:
   {
   }
 
-  handler_work_base(const executor_type& ex,
+  handler_work_base(bool base1_owns_work, const executor_type& ex,
       const executor_type& candidate) BOOST_ASIO_NOEXCEPT
-    : executor_(ex != candidate ? ex : executor_type())
+    : executor_(
+        !base1_owns_work && ex == candidate
+          ? executor_type()
+          : boost::asio::prefer(ex, execution::outstanding_work.tracked))
   {
   }
 
   template <typename OtherExecutor>
-  handler_work_base(const executor_type& ex,
-      const OtherExecutor&) BOOST_ASIO_NOEXCEPT
+  handler_work_base(bool /*base1_owns_work*/, const executor_type& ex,
+      const OtherExecutor& /*candidate*/) BOOST_ASIO_NOEXCEPT
     : executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked))
   {
   }
@@ -450,7 +460,8 @@ public:
 
   handler_work(Handler& handler, const IoExecutor& io_ex) BOOST_ASIO_NOEXCEPT
     : base1_type(0, 0, io_ex),
-      base2_type(boost::asio::get_associated_executor(handler, io_ex), io_ex)
+      base2_type(base1_type::owns_work(),
+          boost::asio::get_associated_executor(handler, io_ex), io_ex)
   {
   }
 
diff --git a/boost/asio/detail/hash_map.hpp b/boost/asio/detail/hash_map.hpp
index a5d5f7ae4aa9fb1abf1408aa602f5c4567f1f661..bc17041622071b5e6718149799a9ee8f8c18b53a 100644
--- a/boost/asio/detail/hash_map.hpp
+++ b/boost/asio/detail/hash_map.hpp
@@ -2,7 +2,7 @@
 // detail/hash_map.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/buffer_sequence_adapter.ipp b/boost/asio/detail/impl/buffer_sequence_adapter.ipp
index c0a878b00496879f27c97fa35a1ef9d121aab7e4..0aadb8243aebc7d65d1d7258f9e3b38732cabbc3 100644
--- a/boost/asio/detail/impl/buffer_sequence_adapter.ipp
+++ b/boost/asio/detail/impl/buffer_sequence_adapter.ipp
@@ -2,7 +2,7 @@
 // detail/impl/buffer_sequence_adapter.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/descriptor_ops.ipp b/boost/asio/detail/impl/descriptor_ops.ipp
index 4701286dcbc323237b7d9d293d68f428c87bbb00..d753e112cf46acbdbca9b9a66921c085e5d14187 100644
--- a/boost/asio/detail/impl/descriptor_ops.ipp
+++ b/boost/asio/detail/impl/descriptor_ops.ipp
@@ -2,7 +2,7 @@
 // detail/impl/descriptor_ops.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -38,6 +38,14 @@ int open(const char* path, int flags, boost::system::error_code& ec)
   return result;
 }
 
+int open(const char* path, int flags,
+    unsigned mode, boost::system::error_code& ec)
+{
+  int result = ::open(path, flags, mode);
+  get_last_error(ec, result < 0);
+  return result;
+}
+
 int close(int d, state_type& state, boost::system::error_code& ec)
 {
   int result = 0;
@@ -468,6 +476,323 @@ bool non_blocking_write1(int d, const void* data, std::size_t size,
   }
 }
 
+#if defined(BOOST_ASIO_HAS_FILE)
+
+std::size_t sync_read_at(int d, state_type state, uint64_t offset,
+    buf* bufs, std::size_t count, bool all_empty, boost::system::error_code& ec)
+{
+  if (d == -1)
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return 0;
+  }
+
+  // A request to read 0 bytes on a stream is a no-op.
+  if (all_empty)
+  {
+    ec.assign(0, ec.category());
+    return 0;
+  }
+
+  // Read some data.
+  for (;;)
+  {
+    // Try to complete the operation without blocking.
+    signed_size_type bytes = ::preadv(d, bufs, static_cast<int>(count), offset);
+    get_last_error(ec, bytes < 0);
+
+    // Check if operation succeeded.
+    if (bytes > 0)
+      return bytes;
+
+    // Check for EOF.
+    if (bytes == 0)
+    {
+      ec = boost::asio::error::eof;
+      return 0;
+    }
+
+    // Operation failed.
+    if ((state & user_set_non_blocking)
+        || (ec != boost::asio::error::would_block
+          && ec != boost::asio::error::try_again))
+      return 0;
+
+    // Wait for descriptor to become ready.
+    if (descriptor_ops::poll_read(d, 0, ec) < 0)
+      return 0;
+  }
+}
+
+std::size_t sync_read_at1(int d, state_type state, uint64_t offset,
+    void* data, std::size_t size, boost::system::error_code& ec)
+{
+  if (d == -1)
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return 0;
+  }
+
+  // A request to read 0 bytes on a stream is a no-op.
+  if (size == 0)
+  {
+    ec.assign(0, ec.category());
+    return 0;
+  }
+
+  // Read some data.
+  for (;;)
+  {
+    // Try to complete the operation without blocking.
+    signed_size_type bytes = ::pread(d, data, size, offset);
+    get_last_error(ec, bytes < 0);
+
+    // Check if operation succeeded.
+    if (bytes > 0)
+      return bytes;
+
+    // Check for EOF.
+    if (bytes == 0)
+    {
+      ec = boost::asio::error::eof;
+      return 0;
+    }
+
+    // Operation failed.
+    if ((state & user_set_non_blocking)
+        || (ec != boost::asio::error::would_block
+          && ec != boost::asio::error::try_again))
+      return 0;
+
+    // Wait for descriptor to become ready.
+    if (descriptor_ops::poll_read(d, 0, ec) < 0)
+      return 0;
+  }
+}
+
+bool non_blocking_read_at(int d, uint64_t offset, buf* bufs, std::size_t count,
+    boost::system::error_code& ec, std::size_t& bytes_transferred)
+{
+  for (;;)
+  {
+    // Read some data.
+    signed_size_type bytes = ::preadv(d, bufs, static_cast<int>(count), offset);
+    get_last_error(ec, bytes < 0);
+
+    // Check for EOF.
+    if (bytes == 0)
+    {
+      ec = boost::asio::error::eof;
+      return true;
+    }
+
+    // Check if operation succeeded.
+    if (bytes > 0)
+    {
+      bytes_transferred = bytes;
+      return true;
+    }
+
+    // Retry operation if interrupted by signal.
+    if (ec == boost::asio::error::interrupted)
+      continue;
+
+    // Check if we need to run the operation again.
+    if (ec == boost::asio::error::would_block
+        || ec == boost::asio::error::try_again)
+      return false;
+
+    // Operation failed.
+    bytes_transferred = 0;
+    return true;
+  }
+}
+
+bool non_blocking_read_at1(int d, uint64_t offset, void* data, std::size_t size,
+    boost::system::error_code& ec, std::size_t& bytes_transferred)
+{
+  for (;;)
+  {
+    // Read some data.
+    signed_size_type bytes = ::pread(d, data, size, offset);
+    get_last_error(ec, bytes < 0);
+
+    // Check for EOF.
+    if (bytes == 0)
+    {
+      ec = boost::asio::error::eof;
+      return true;
+    }
+
+    // Check if operation succeeded.
+    if (bytes > 0)
+    {
+      bytes_transferred = bytes;
+      return true;
+    }
+
+    // Retry operation if interrupted by signal.
+    if (ec == boost::asio::error::interrupted)
+      continue;
+
+    // Check if we need to run the operation again.
+    if (ec == boost::asio::error::would_block
+        || ec == boost::asio::error::try_again)
+      return false;
+
+    // Operation failed.
+    bytes_transferred = 0;
+    return true;
+  }
+}
+
+std::size_t sync_write_at(int d, state_type state, uint64_t offset,
+    const buf* bufs, std::size_t count, bool all_empty,
+    boost::system::error_code& ec)
+{
+  if (d == -1)
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return 0;
+  }
+
+  // A request to write 0 bytes on a stream is a no-op.
+  if (all_empty)
+  {
+    ec.assign(0, ec.category());
+    return 0;
+  }
+
+  // Write some data.
+  for (;;)
+  {
+    // Try to complete the operation without blocking.
+    signed_size_type bytes = ::pwritev(d,
+        bufs, static_cast<int>(count), offset);
+    get_last_error(ec, bytes < 0);
+
+    // Check if operation succeeded.
+    if (bytes > 0)
+      return bytes;
+
+    // Operation failed.
+    if ((state & user_set_non_blocking)
+        || (ec != boost::asio::error::would_block
+          && ec != boost::asio::error::try_again))
+      return 0;
+
+    // Wait for descriptor to become ready.
+    if (descriptor_ops::poll_write(d, 0, ec) < 0)
+      return 0;
+  }
+}
+
+std::size_t sync_write_at1(int d, state_type state, uint64_t offset,
+    const void* data, std::size_t size, boost::system::error_code& ec)
+{
+  if (d == -1)
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return 0;
+  }
+
+  // A request to write 0 bytes on a stream is a no-op.
+  if (size == 0)
+  {
+    ec.assign(0, ec.category());
+    return 0;
+  }
+
+  // Write some data.
+  for (;;)
+  {
+    // Try to complete the operation without blocking.
+    signed_size_type bytes = ::pwrite(d, data, size, offset);
+    get_last_error(ec, bytes < 0);
+
+    // Check if operation succeeded.
+    if (bytes > 0)
+      return bytes;
+
+    // Operation failed.
+    if ((state & user_set_non_blocking)
+        || (ec != boost::asio::error::would_block
+          && ec != boost::asio::error::try_again))
+      return 0;
+
+    // Wait for descriptor to become ready.
+    if (descriptor_ops::poll_write(d, 0, ec) < 0)
+      return 0;
+  }
+}
+
+bool non_blocking_write_at(int d, uint64_t offset,
+    const buf* bufs, std::size_t count,
+    boost::system::error_code& ec, std::size_t& bytes_transferred)
+{
+  for (;;)
+  {
+    // Write some data.
+    signed_size_type bytes = ::pwritev(d,
+        bufs, static_cast<int>(count), offset);
+    get_last_error(ec, bytes < 0);
+
+    // Check if operation succeeded.
+    if (bytes >= 0)
+    {
+      bytes_transferred = bytes;
+      return true;
+    }
+
+    // Retry operation if interrupted by signal.
+    if (ec == boost::asio::error::interrupted)
+      continue;
+
+    // Check if we need to run the operation again.
+    if (ec == boost::asio::error::would_block
+        || ec == boost::asio::error::try_again)
+      return false;
+
+    // Operation failed.
+    bytes_transferred = 0;
+    return true;
+  }
+}
+
+bool non_blocking_write_at1(int d, uint64_t offset,
+    const void* data, std::size_t size,
+    boost::system::error_code& ec, std::size_t& bytes_transferred)
+{
+  for (;;)
+  {
+    // Write some data.
+    signed_size_type bytes = ::pwrite(d, data, size, offset);
+    get_last_error(ec, bytes < 0);
+
+    // Check if operation succeeded.
+    if (bytes >= 0)
+    {
+      bytes_transferred = bytes;
+      return true;
+    }
+
+    // Retry operation if interrupted by signal.
+    if (ec == boost::asio::error::interrupted)
+      continue;
+
+    // Check if we need to run the operation again.
+    if (ec == boost::asio::error::would_block
+        || ec == boost::asio::error::try_again)
+      return false;
+
+    // Operation failed.
+    bytes_transferred = 0;
+    return true;
+  }
+}
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+
 int ioctl(int d, state_type& state, long cmd,
     ioctl_arg_type* arg, boost::system::error_code& ec)
 {
diff --git a/boost/asio/detail/impl/dev_poll_reactor.hpp b/boost/asio/detail/impl/dev_poll_reactor.hpp
index 87ed83edf45a5cdf04793f3345affee5e05fdcec..72a7ce22122602e66f963b8bce9df72e72a39db4 100644
--- a/boost/asio/detail/impl/dev_poll_reactor.hpp
+++ b/boost/asio/detail/impl/dev_poll_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/impl/dev_poll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,12 +19,20 @@
 
 #if defined(BOOST_ASIO_HAS_DEV_POLL)
 
+#include <boost/asio/detail/scheduler.hpp>
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
+inline void dev_poll_reactor::post_immediate_completion(
+    reactor_op* op, bool is_continuation)
+{
+  scheduler_.post_immediate_completion(op, is_continuation);
+}
+
 template <typename Time_Traits>
 void dev_poll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
 {
@@ -69,6 +77,18 @@ std::size_t dev_poll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
   return n;
 }
 
+template <typename Time_Traits>
+void dev_poll_reactor::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data* timer,
+    void* cancellation_key)
+{
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  queue.cancel_timer_by_key(timer, ops, cancellation_key);
+  lock.unlock();
+  scheduler_.post_deferred_completions(ops);
+}
+
 template <typename Time_Traits>
 void dev_poll_reactor::move_timer(timer_queue<Time_Traits>& queue,
     typename timer_queue<Time_Traits>::per_timer_data& target,
diff --git a/boost/asio/detail/impl/dev_poll_reactor.ipp b/boost/asio/detail/impl/dev_poll_reactor.ipp
index abd8bab1706e169d6de7fa07c9885e327077d3d5..60b9c111c96114b481b6875f98b7befd1c120c31 100644
--- a/boost/asio/detail/impl/dev_poll_reactor.ipp
+++ b/boost/asio/detail/impl/dev_poll_reactor.ipp
@@ -2,7 +2,7 @@
 // detail/impl/dev_poll_reactor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -21,6 +21,7 @@
 
 #include <boost/asio/detail/dev_poll_reactor.hpp>
 #include <boost/asio/detail/assert.hpp>
+#include <boost/asio/detail/scheduler.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
@@ -202,6 +203,19 @@ void dev_poll_reactor::cancel_ops(socket_type descriptor,
   cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted);
 }
 
+void dev_poll_reactor::cancel_ops_by_key(socket_type descriptor,
+    dev_poll_reactor::per_descriptor_data&,
+    int op_type, void* cancellation_key)
+{
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  bool need_interrupt = op_queue_[op_type].cancel_operations_by_key(
+      descriptor, ops, cancellation_key, boost::asio::error::operation_aborted);
+  scheduler_.post_deferred_completions(ops);
+  if (need_interrupt)
+    interrupter_.interrupt();
+}
+
 void dev_poll_reactor::deregister_descriptor(socket_type descriptor,
     dev_poll_reactor::per_descriptor_data&, bool)
 {
diff --git a/boost/asio/detail/impl/epoll_reactor.hpp b/boost/asio/detail/impl/epoll_reactor.hpp
index 70791c461701a0493f4f029e5cfcdaee4f7fcd99..8c618e32e1ce65833c7e9db4070d6f0f8e2905db 100644
--- a/boost/asio/detail/impl/epoll_reactor.hpp
+++ b/boost/asio/detail/impl/epoll_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/impl/epoll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,12 +17,20 @@
 
 #if defined(BOOST_ASIO_HAS_EPOLL)
 
+#include <boost/asio/detail/scheduler.hpp>
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
+inline void epoll_reactor::post_immediate_completion(
+    operation* op, bool is_continuation)
+{
+  scheduler_.post_immediate_completion(op, is_continuation);
+}
+
 template <typename Time_Traits>
 void epoll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
 {
@@ -67,6 +75,18 @@ std::size_t epoll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
   return n;
 }
 
+template <typename Time_Traits>
+void epoll_reactor::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data* timer,
+    void* cancellation_key)
+{
+  mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  queue.cancel_timer_by_key(timer, ops, cancellation_key);
+  lock.unlock();
+  scheduler_.post_deferred_completions(ops);
+}
+
 template <typename Time_Traits>
 void epoll_reactor::move_timer(timer_queue<Time_Traits>& queue,
     typename timer_queue<Time_Traits>::per_timer_data& target,
diff --git a/boost/asio/detail/impl/epoll_reactor.ipp b/boost/asio/detail/impl/epoll_reactor.ipp
index b57da8581f8c8c939665dbba6a7e35c5c328b12f..214ed192a8afe537c2fb33c2dbaa5720482fc318 100644
--- a/boost/asio/detail/impl/epoll_reactor.ipp
+++ b/boost/asio/detail/impl/epoll_reactor.ipp
@@ -2,7 +2,7 @@
 // detail/impl/epoll_reactor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,6 +22,7 @@
 #include <cstddef>
 #include <sys/epoll.h>
 #include <boost/asio/detail/epoll_reactor.hpp>
+#include <boost/asio/detail/scheduler.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
@@ -343,6 +344,35 @@ void epoll_reactor::cancel_ops(socket_type,
   scheduler_.post_deferred_completions(ops);
 }
 
+void epoll_reactor::cancel_ops_by_key(socket_type,
+    epoll_reactor::per_descriptor_data& descriptor_data,
+    int op_type, void* cancellation_key)
+{
+  if (!descriptor_data)
+    return;
+
+  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+
+  op_queue<operation> ops;
+  op_queue<reactor_op> other_ops;
+  while (reactor_op* op = descriptor_data->op_queue_[op_type].front())
+  {
+    descriptor_data->op_queue_[op_type].pop();
+    if (op->cancellation_key_ == cancellation_key)
+    {
+      op->ec_ = boost::asio::error::operation_aborted;
+      ops.push(op);
+    }
+    else
+      other_ops.push(op);
+  }
+  descriptor_data->op_queue_[op_type].push(other_ops);
+
+  descriptor_lock.unlock();
+
+  scheduler_.post_deferred_completions(ops);
+}
+
 void epoll_reactor::deregister_descriptor(socket_type descriptor,
     epoll_reactor::per_descriptor_data& descriptor_data, bool closing)
 {
diff --git a/boost/asio/detail/impl/eventfd_select_interrupter.ipp b/boost/asio/detail/impl/eventfd_select_interrupter.ipp
index 6c499781fc4533896a042a08ef1d426224f1f8d4..f72c4fb140b7edc322cd05b78abfa87e66584e7e 100644
--- a/boost/asio/detail/impl/eventfd_select_interrupter.ipp
+++ b/boost/asio/detail/impl/eventfd_select_interrupter.ipp
@@ -2,7 +2,7 @@
 // detail/impl/eventfd_select_interrupter.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Roelof Naude (roelof.naude at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/detail/impl/handler_tracking.ipp b/boost/asio/detail/impl/handler_tracking.ipp
index b23f1a78aa2fe3ef9c520ff9b914bcb74fd3e5ea..8d3da01a6bc827ea5ab29ebf65a8dd1d1368a2fa 100644
--- a/boost/asio/detail/impl/handler_tracking.ipp
+++ b/boost/asio/detail/impl/handler_tracking.ipp
@@ -2,7 +2,7 @@
 // detail/impl/handler_tracking.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/io_uring_descriptor_service.ipp b/boost/asio/detail/impl/io_uring_descriptor_service.ipp
new file mode 100644
index 0000000000000000000000000000000000000000..95a4d2c60b78530095ab439d43c3531f821e8805
--- /dev/null
+++ b/boost/asio/detail/impl/io_uring_descriptor_service.ipp
@@ -0,0 +1,204 @@
+//
+// detail/impl/io_uring_descriptor_service.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IMPL_IO_URING_DESCRIPTOR_SERVICE_IPP
+#define BOOST_ASIO_DETAIL_IMPL_IO_URING_DESCRIPTOR_SERVICE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/detail/io_uring_descriptor_service.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+io_uring_descriptor_service::io_uring_descriptor_service(
+    execution_context& context)
+  : execution_context_service_base<io_uring_descriptor_service>(context),
+    io_uring_service_(boost::asio::use_service<io_uring_service>(context))
+{
+  io_uring_service_.init_task();
+}
+
+void io_uring_descriptor_service::shutdown()
+{
+}
+
+void io_uring_descriptor_service::construct(
+    io_uring_descriptor_service::implementation_type& impl)
+{
+  impl.descriptor_ = -1;
+  impl.state_ = 0;
+  impl.io_object_data_ = 0;
+}
+
+void io_uring_descriptor_service::move_construct(
+    io_uring_descriptor_service::implementation_type& impl,
+    io_uring_descriptor_service::implementation_type& other_impl)
+  BOOST_ASIO_NOEXCEPT
+{
+  impl.descriptor_ = other_impl.descriptor_;
+  other_impl.descriptor_ = -1;
+
+  impl.state_ = other_impl.state_;
+  other_impl.state_ = 0;
+
+  impl.io_object_data_ = other_impl.io_object_data_;
+  other_impl.io_object_data_ = 0;
+}
+
+void io_uring_descriptor_service::move_assign(
+    io_uring_descriptor_service::implementation_type& impl,
+    io_uring_descriptor_service& /*other_service*/,
+    io_uring_descriptor_service::implementation_type& other_impl)
+{
+  destroy(impl);
+
+  impl.descriptor_ = other_impl.descriptor_;
+  other_impl.descriptor_ = -1;
+
+  impl.state_ = other_impl.state_;
+  other_impl.state_ = 0;
+
+  impl.io_object_data_ = other_impl.io_object_data_;
+  other_impl.io_object_data_ = 0;
+}
+
+void io_uring_descriptor_service::destroy(
+    io_uring_descriptor_service::implementation_type& impl)
+{
+  if (is_open(impl))
+  {
+    BOOST_ASIO_HANDLER_OPERATION((io_uring_service_.context(),
+          "descriptor", &impl, impl.descriptor_, "close"));
+
+    io_uring_service_.deregister_io_object(impl.io_object_data_);
+    boost::system::error_code ignored_ec;
+    descriptor_ops::close(impl.descriptor_, impl.state_, ignored_ec);
+    io_uring_service_.cleanup_io_object(impl.io_object_data_);
+  }
+}
+
+boost::system::error_code io_uring_descriptor_service::assign(
+    io_uring_descriptor_service::implementation_type& impl,
+    const native_handle_type& native_descriptor, boost::system::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    ec = boost::asio::error::already_open;
+    return ec;
+  }
+
+  io_uring_service_.register_io_object(impl.io_object_data_);
+
+  impl.descriptor_ = native_descriptor;
+  impl.state_ = descriptor_ops::possible_dup;
+  ec = success_ec_;
+  return ec;
+}
+
+boost::system::error_code io_uring_descriptor_service::close(
+    io_uring_descriptor_service::implementation_type& impl,
+    boost::system::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    BOOST_ASIO_HANDLER_OPERATION((io_uring_service_.context(),
+          "descriptor", &impl, impl.descriptor_, "close"));
+
+    io_uring_service_.deregister_io_object(impl.io_object_data_);
+    descriptor_ops::close(impl.descriptor_, impl.state_, ec);
+    io_uring_service_.cleanup_io_object(impl.io_object_data_);
+  }
+  else
+  {
+    ec = success_ec_;
+  }
+
+  // The descriptor is closed by the OS even if close() returns an error.
+  //
+  // (Actually, POSIX says the state of the descriptor is unspecified. On
+  // Linux the descriptor is apparently closed anyway; e.g. see
+  //   http://lkml.org/lkml/2005/9/10/129
+  construct(impl);
+
+  return ec;
+}
+
+io_uring_descriptor_service::native_handle_type
+io_uring_descriptor_service::release(
+    io_uring_descriptor_service::implementation_type& impl)
+{
+  native_handle_type descriptor = impl.descriptor_;
+
+  if (is_open(impl))
+  {
+    BOOST_ASIO_HANDLER_OPERATION((io_uring_service_.context(),
+          "descriptor", &impl, impl.descriptor_, "release"));
+
+    io_uring_service_.deregister_io_object(impl.io_object_data_);
+    io_uring_service_.cleanup_io_object(impl.io_object_data_);
+    construct(impl);
+  }
+
+  return descriptor;
+}
+
+boost::system::error_code io_uring_descriptor_service::cancel(
+    io_uring_descriptor_service::implementation_type& impl,
+    boost::system::error_code& ec)
+{
+  if (!is_open(impl))
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return ec;
+  }
+
+  BOOST_ASIO_HANDLER_OPERATION((io_uring_service_.context(),
+        "descriptor", &impl, impl.descriptor_, "cancel"));
+
+  io_uring_service_.cancel_ops(impl.io_object_data_);
+  ec = success_ec_;
+  return ec;
+}
+
+void io_uring_descriptor_service::start_op(
+    io_uring_descriptor_service::implementation_type& impl,
+    int op_type, io_uring_operation* op, bool is_continuation, bool noop)
+{
+  if (!noop)
+  {
+    io_uring_service_.start_op(op_type,
+        impl.io_object_data_, op, is_continuation);
+  }
+  else
+  {
+    io_uring_service_.post_immediate_completion(op, is_continuation);
+  }
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_IO_URING_DESCRIPTOR_SERVICE_IPP
diff --git a/boost/asio/detail/impl/io_uring_file_service.ipp b/boost/asio/detail/impl/io_uring_file_service.ipp
new file mode 100644
index 0000000000000000000000000000000000000000..3ee14c486d995ea669744b306cdc3731d8b3acf8
--- /dev/null
+++ b/boost/asio/detail/impl/io_uring_file_service.ipp
@@ -0,0 +1,133 @@
+//
+// detail/impl/io_uring_file_service.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IMPL_IO_URING_FILE_SERVICE_IPP
+#define BOOST_ASIO_DETAIL_IMPL_IO_URING_FILE_SERVICE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_FILE) \
+  && defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <cstring>
+#include <sys/stat.h>
+#include <boost/asio/detail/io_uring_file_service.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+io_uring_file_service::io_uring_file_service(
+    execution_context& context)
+  : execution_context_service_base<io_uring_file_service>(context),
+    descriptor_service_(context)
+{
+}
+
+void io_uring_file_service::shutdown()
+{
+  descriptor_service_.shutdown();
+}
+
+boost::system::error_code io_uring_file_service::open(
+    io_uring_file_service::implementation_type& impl,
+    const char* path, file_base::flags open_flags,
+    boost::system::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    ec = boost::asio::error::already_open;
+    return ec;
+  }
+
+  descriptor_ops::state_type state = 0;
+  int fd = descriptor_ops::open(path, static_cast<int>(open_flags), 0777, ec);
+  if (fd < 0)
+    return ec;
+
+  // We're done. Take ownership of the serial port descriptor.
+  if (descriptor_service_.assign(impl, fd, ec))
+  {
+    boost::system::error_code ignored_ec;
+    descriptor_ops::close(fd, state, ignored_ec);
+  }
+
+  (void)::posix_fadvise(native_handle(impl), 0, 0,
+      impl.is_stream_ ? POSIX_FADV_SEQUENTIAL : POSIX_FADV_RANDOM);
+
+  return ec;
+}
+
+uint64_t io_uring_file_service::size(
+    const io_uring_file_service::implementation_type& impl,
+    boost::system::error_code& ec) const
+{
+  struct stat s;
+  int result = ::fstat(native_handle(impl), &s);
+  descriptor_ops::get_last_error(ec, result != 0);
+  return !ec ? s.st_size : 0;
+}
+
+boost::system::error_code io_uring_file_service::resize(
+    io_uring_file_service::implementation_type& impl,
+    uint64_t n, boost::system::error_code& ec)
+{
+  int result = ::ftruncate(native_handle(impl), n);
+  descriptor_ops::get_last_error(ec, result != 0);
+  return ec;
+}
+
+boost::system::error_code io_uring_file_service::sync_all(
+    io_uring_file_service::implementation_type& impl,
+    boost::system::error_code& ec)
+{
+  int result = ::fsync(native_handle(impl));
+  descriptor_ops::get_last_error(ec, result != 0);
+  return ec;
+}
+
+boost::system::error_code io_uring_file_service::sync_data(
+    io_uring_file_service::implementation_type& impl,
+    boost::system::error_code& ec)
+{
+#if defined(_POSIX_SYNCHRONIZED_IO)
+  int result = ::fdatasync(native_handle(impl));
+#else // defined(_POSIX_SYNCHRONIZED_IO)
+  int result = ::fsync(native_handle(impl));
+#endif // defined(_POSIX_SYNCHRONIZED_IO)
+  descriptor_ops::get_last_error(ec, result != 0);
+  return ec;
+}
+
+uint64_t io_uring_file_service::seek(
+    io_uring_file_service::implementation_type& impl, int64_t offset,
+    file_base::seek_basis whence, boost::system::error_code& ec)
+{
+  int64_t result = ::lseek(native_handle(impl), offset, whence);
+  descriptor_ops::get_last_error(ec, result < 0);
+  return !ec ? static_cast<uint64_t>(result) : 0;
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+       //   && defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_IO_URING_FILE_SERVICE_IPP
diff --git a/boost/asio/detail/impl/io_uring_service.hpp b/boost/asio/detail/impl/io_uring_service.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..314e1f73371b6f6879ffc75b210c00bfd9cb2264
--- /dev/null
+++ b/boost/asio/detail/impl/io_uring_service.hpp
@@ -0,0 +1,114 @@
+//
+// detail/impl/io_uring_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IMPL_IO_URING_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_IMPL_IO_URING_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/detail/scheduler.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+inline void io_uring_service::post_immediate_completion(
+    operation* op, bool is_continuation)
+{
+  scheduler_.post_immediate_completion(op, is_continuation);
+}
+
+template <typename Time_Traits>
+void io_uring_service::add_timer_queue(timer_queue<Time_Traits>& queue)
+{
+  do_add_timer_queue(queue);
+}
+
+template <typename Time_Traits>
+void io_uring_service::remove_timer_queue(timer_queue<Time_Traits>& queue)
+{
+  do_remove_timer_queue(queue);
+}
+
+template <typename Time_Traits>
+void io_uring_service::schedule_timer(timer_queue<Time_Traits>& queue,
+    const typename Time_Traits::time_type& time,
+    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
+{
+  mutex::scoped_lock lock(mutex_);
+
+  if (shutdown_)
+  {
+    scheduler_.post_immediate_completion(op, false);
+    return;
+  }
+
+  bool earliest = queue.enqueue_timer(time, timer, op);
+  scheduler_.work_started();
+  if (earliest)
+  {
+    update_timeout();
+    post_submit_sqes_op(lock);
+  }
+}
+
+template <typename Time_Traits>
+std::size_t io_uring_service::cancel_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& timer,
+    std::size_t max_cancelled)
+{
+  mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
+  lock.unlock();
+  scheduler_.post_deferred_completions(ops);
+  return n;
+}
+
+template <typename Time_Traits>
+void io_uring_service::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data* timer,
+    void* cancellation_key)
+{
+  mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  queue.cancel_timer_by_key(timer, ops, cancellation_key);
+  lock.unlock();
+  scheduler_.post_deferred_completions(ops);
+}
+
+template <typename Time_Traits>
+void io_uring_service::move_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& target,
+    typename timer_queue<Time_Traits>::per_timer_data& source)
+{
+  mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  queue.cancel_timer(target, ops);
+  queue.move_timer(target, source);
+  lock.unlock();
+  scheduler_.post_deferred_completions(ops);
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_IO_URING_SERVICE_HPP
diff --git a/boost/asio/detail/impl/io_uring_service.ipp b/boost/asio/detail/impl/io_uring_service.ipp
new file mode 100644
index 0000000000000000000000000000000000000000..3291d04276c79b86cf0f2f6ba20e3dfd1dd1b366
--- /dev/null
+++ b/boost/asio/detail/impl/io_uring_service.ipp
@@ -0,0 +1,882 @@
+//
+// detail/impl/io_uring_service.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IMPL_IO_URING_SERVICE_IPP
+#define BOOST_ASIO_DETAIL_IMPL_IO_URING_SERVICE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <cstddef>
+#include <sys/eventfd.h>
+#include <boost/asio/detail/io_uring_service.hpp>
+#include <boost/asio/detail/reactor_op.hpp>
+#include <boost/asio/detail/scheduler.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+io_uring_service::io_uring_service(boost::asio::execution_context& ctx)
+  : execution_context_service_base<io_uring_service>(ctx),
+    scheduler_(use_service<scheduler>(ctx)),
+    mutex_(BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING(
+          REACTOR_REGISTRATION, scheduler_.concurrency_hint())),
+    outstanding_work_(0),
+    submit_sqes_op_(this),
+    pending_sqes_(0),
+    pending_submit_sqes_op_(false),
+    shutdown_(false),
+    timeout_(),
+    registration_mutex_(mutex_.enabled()),
+    reactor_(use_service<reactor>(ctx)),
+    reactor_data_(),
+    event_fd_(-1)
+{
+  reactor_.init_task();
+  init_ring();
+  register_with_reactor();
+}
+
+io_uring_service::~io_uring_service()
+{
+  if (ring_.ring_fd != -1)
+    ::io_uring_queue_exit(&ring_);
+  if (event_fd_ != -1)
+    ::close(event_fd_);
+}
+
+void io_uring_service::shutdown()
+{
+  mutex::scoped_lock lock(mutex_);
+  shutdown_ = true;
+  lock.unlock();
+
+  op_queue<operation> ops;
+
+  // Cancel all outstanding operations.
+  while (io_object* io_obj = registered_io_objects_.first())
+  {
+    for (int i = 0; i < max_ops; ++i)
+    {
+      if (!io_obj->queues_[i].op_queue_.empty())
+      {
+        ops.push(io_obj->queues_[i].op_queue_);
+        if (::io_uring_sqe* sqe = get_sqe())
+          ::io_uring_prep_cancel(sqe, &io_obj->queues_[i], 0);
+      }
+    }
+    io_obj->shutdown_ = true;
+    registered_io_objects_.free(io_obj);
+  }
+
+  // Cancel the timeout operation.
+  if (::io_uring_sqe* sqe = get_sqe())
+    ::io_uring_prep_cancel(sqe, &timeout_, IOSQE_IO_DRAIN);
+  submit_sqes();
+
+  // Wait for all completions to come back.
+  for (; outstanding_work_ > 0; --outstanding_work_)
+  {
+    ::io_uring_cqe* cqe = 0;
+    if (::io_uring_wait_cqe(&ring_, &cqe) != 0)
+      break;
+  }
+
+  timer_queues_.get_all_timers(ops);
+
+  scheduler_.abandon_operations(ops);
+}
+
+void io_uring_service::notify_fork(
+    boost::asio::execution_context::fork_event fork_ev)
+{
+  switch (fork_ev)
+  {
+  case boost::asio::execution_context::fork_prepare:
+    {
+      // Cancel all outstanding operations. They will be restarted
+      // after the fork completes.
+      mutex::scoped_lock registration_lock(registration_mutex_);
+      for (io_object* io_obj = registered_io_objects_.first();
+          io_obj != 0; io_obj = io_obj->next_)
+      {
+        mutex::scoped_lock io_object_lock(io_obj->mutex_);
+        for (int i = 0; i < max_ops; ++i)
+        {
+          if (!io_obj->queues_[i].op_queue_.empty()
+              && !io_obj->queues_[i].cancel_requested_)
+          {
+            mutex::scoped_lock lock(mutex_);
+            if (::io_uring_sqe* sqe = get_sqe())
+              ::io_uring_prep_cancel(sqe, &io_obj->queues_[i], 0);
+          }
+        }
+      }
+
+      // Cancel the timeout operation.
+      {
+        mutex::scoped_lock lock(mutex_);
+        if (::io_uring_sqe* sqe = get_sqe())
+          ::io_uring_prep_cancel(sqe, &timeout_, IOSQE_IO_DRAIN);
+        submit_sqes();
+      }
+
+      // Wait for all completions to come back, and post all completed I/O
+      // queues to the scheduler. Note that some operations may have already
+      // completed, or were explicitly cancelled. All others will be
+      // automatically restarted.
+      op_queue<operation> ops;
+      for (; outstanding_work_ > 0; --outstanding_work_)
+      {
+        ::io_uring_cqe* cqe = 0;
+        if (::io_uring_wait_cqe(&ring_, &cqe) != 0)
+          break;
+        if (void* ptr = ::io_uring_cqe_get_data(cqe))
+        {
+          if (ptr != this && ptr != &timer_queues_ && ptr != &timeout_)
+          {
+            io_queue* io_q = static_cast<io_queue*>(ptr);
+            io_q->set_result(cqe->res);
+            ops.push(io_q);
+          }
+        }
+      }
+      scheduler_.post_deferred_completions(ops);
+
+      // Restart and eventfd operation.
+      register_with_reactor();
+    }
+    break;
+
+  case boost::asio::execution_context::fork_parent:
+    // Restart the timeout and eventfd operations.
+    update_timeout();
+    register_with_reactor();
+    break;
+
+  case boost::asio::execution_context::fork_child:
+    {
+      // The child process gets a new io_uring instance.
+      ::io_uring_queue_exit(&ring_);
+      init_ring();
+      register_with_reactor();
+    }
+    break;
+  default:
+    break;
+  }
+}
+
+void io_uring_service::init_task()
+{
+  scheduler_.init_task();
+}
+
+void io_uring_service::register_io_object(
+    io_uring_service::per_io_object_data& io_obj)
+{
+  io_obj = allocate_io_object();
+
+  mutex::scoped_lock io_object_lock(io_obj->mutex_);
+
+  io_obj->service_ = this;
+  io_obj->shutdown_ = false;
+  for (int i = 0; i < max_ops; ++i)
+  {
+    io_obj->queues_[i].io_object_ = io_obj;
+    io_obj->queues_[i].cancel_requested_ = false;
+  }
+}
+
+void io_uring_service::register_internal_io_object(
+    io_uring_service::per_io_object_data& io_obj,
+    int op_type, io_uring_operation* op)
+{
+  io_obj = allocate_io_object();
+
+  mutex::scoped_lock io_object_lock(io_obj->mutex_);
+
+  io_obj->service_ = this;
+  io_obj->shutdown_ = false;
+  for (int i = 0; i < max_ops; ++i)
+  {
+    io_obj->queues_[i].io_object_ = io_obj;
+    io_obj->queues_[i].cancel_requested_ = false;
+  }
+
+  io_obj->queues_[op_type].op_queue_.push(op);
+  io_object_lock.unlock();
+  mutex::scoped_lock lock(mutex_);
+  if (::io_uring_sqe* sqe = get_sqe())
+  {
+    op->prepare(sqe);
+    ::io_uring_sqe_set_data(sqe, &io_obj->queues_[op_type]);
+    post_submit_sqes_op(lock);
+  }
+  else
+  {
+    boost::system::error_code ec(ENOBUFS,
+        boost::asio::error::get_system_category());
+    boost::asio::detail::throw_error(ec, "io_uring_get_sqe");
+  }
+}
+
+void io_uring_service::register_buffers(const ::iovec* v, unsigned n)
+{
+  int result = ::io_uring_register_buffers(&ring_, v, n);
+  if (result < 0)
+  {
+    boost::system::error_code ec(-result,
+        boost::asio::error::get_system_category());
+    boost::asio::detail::throw_error(ec, "io_uring_register_buffers");
+  }
+}
+
+void io_uring_service::unregister_buffers()
+{
+  (void)::io_uring_unregister_buffers(&ring_);
+}
+
+void io_uring_service::start_op(int op_type,
+    io_uring_service::per_io_object_data& io_obj,
+    io_uring_operation* op, bool is_continuation)
+{
+  if (!io_obj)
+  {
+    op->ec_ = boost::asio::error::bad_descriptor;
+    post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  mutex::scoped_lock io_object_lock(io_obj->mutex_);
+
+  if (io_obj->shutdown_)
+  {
+    io_object_lock.unlock();
+    post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  if (io_obj->queues_[op_type].op_queue_.empty())
+  {
+    if (op->perform(false))
+    {
+      io_object_lock.unlock();
+      scheduler_.post_immediate_completion(op, is_continuation);
+    }
+    else
+    {
+      io_obj->queues_[op_type].op_queue_.push(op);
+      io_object_lock.unlock();
+      mutex::scoped_lock lock(mutex_);
+      if (::io_uring_sqe* sqe = get_sqe())
+      {
+        op->prepare(sqe);
+        ::io_uring_sqe_set_data(sqe, &io_obj->queues_[op_type]);
+        scheduler_.work_started();
+        post_submit_sqes_op(lock);
+      }
+      else
+      {
+        lock.unlock();
+        io_obj->queues_[op_type].set_result(-ENOBUFS);
+        post_immediate_completion(&io_obj->queues_[op_type], is_continuation);
+      }
+    }
+  }
+  else
+  {
+    io_obj->queues_[op_type].op_queue_.push(op);
+    scheduler_.work_started();
+  }
+}
+
+void io_uring_service::cancel_ops(io_uring_service::per_io_object_data& io_obj)
+{
+  if (!io_obj)
+    return;
+
+  mutex::scoped_lock io_object_lock(io_obj->mutex_);
+  op_queue<operation> ops;
+  do_cancel_ops(io_obj, ops);
+  io_object_lock.unlock();
+  scheduler_.post_deferred_completions(ops);
+}
+
+void io_uring_service::cancel_ops_by_key(
+    io_uring_service::per_io_object_data& io_obj,
+    int op_type, void* cancellation_key)
+{
+  if (!io_obj)
+    return;
+
+  mutex::scoped_lock io_object_lock(io_obj->mutex_);
+
+  bool first = true;
+  op_queue<operation> ops;
+  op_queue<io_uring_operation> other_ops;
+  while (io_uring_operation* op = io_obj->queues_[op_type].op_queue_.front())
+  {
+    io_obj->queues_[op_type].op_queue_.pop();
+    if (op->cancellation_key_ == cancellation_key)
+    {
+      if (first)
+      {
+        other_ops.push(op);
+        if (!io_obj->queues_[op_type].cancel_requested_)
+        {
+          io_obj->queues_[op_type].cancel_requested_ = true;
+          mutex::scoped_lock lock(mutex_);
+          if (::io_uring_sqe* sqe = get_sqe())
+          {
+            ::io_uring_prep_cancel(sqe, &io_obj->queues_[op_type], 0);
+            submit_sqes();
+          }
+        }
+      }
+      else
+      {
+        op->ec_ = boost::asio::error::operation_aborted;
+        ops.push(op);
+      }
+    }
+    else
+      other_ops.push(op);
+    first = false;
+  }
+  io_obj->queues_[op_type].op_queue_.push(other_ops);
+
+  io_object_lock.unlock();
+
+  scheduler_.post_deferred_completions(ops);
+}
+
+void io_uring_service::deregister_io_object(
+    io_uring_service::per_io_object_data& io_obj)
+{
+  if (!io_obj)
+    return;
+
+  mutex::scoped_lock io_object_lock(io_obj->mutex_);
+  if (!io_obj->shutdown_)
+  {
+    op_queue<operation> ops;
+    do_cancel_ops(io_obj, ops);
+    io_obj->shutdown_ = true;
+    io_object_lock.unlock();
+    scheduler_.post_deferred_completions(ops);
+
+    // Leave io_obj set so that it will be freed by the subsequent
+    // call to cleanup_io_obj.
+  }
+  else
+  {
+    // We are shutting down, so prevent cleanup_io_object from freeing
+    // the I/O object and let the destructor free it instead.
+    io_obj = 0;
+  }
+}
+
+void io_uring_service::cleanup_io_object(
+    io_uring_service::per_io_object_data& io_obj)
+{
+  if (io_obj)
+  {
+    free_io_object(io_obj);
+    io_obj = 0;
+  }
+}
+
+void io_uring_service::run(long usec, op_queue<operation>& ops)
+{
+  __kernel_timespec ts;
+  int local_ops = 0;
+
+  if (usec > 0)
+  {
+    ts.tv_sec = usec / 1000000;
+    ts.tv_nsec = (usec % 1000000) * 1000;
+    mutex::scoped_lock lock(mutex_);
+    if (::io_uring_sqe* sqe = get_sqe())
+    {
+      ++local_ops;
+      ::io_uring_prep_timeout(sqe, &ts, 0, 0);
+      ::io_uring_sqe_set_data(sqe, &ts);
+      submit_sqes();
+    }
+  }
+
+  ::io_uring_cqe* cqe = 0;
+  int result = (usec == 0)
+    ? ::io_uring_peek_cqe(&ring_, &cqe)
+    : ::io_uring_wait_cqe(&ring_, &cqe);
+
+  if (result == 0 && usec > 0)
+  {
+    if (::io_uring_cqe_get_data(cqe) != &ts)
+    {
+      mutex::scoped_lock lock(mutex_);
+      if (::io_uring_sqe* sqe = get_sqe())
+      {
+        ++local_ops;
+        ::io_uring_prep_timeout_remove(sqe, reinterpret_cast<__u64>(&ts), 0);
+        submit_sqes();
+      }
+    }
+  }
+
+  bool check_timers = false;
+  int count = 0;
+  while (result == 0)
+  {
+    if (void* ptr = ::io_uring_cqe_get_data(cqe))
+    {
+      if (ptr == this)
+      {
+        // The io_uring service was interrupted.
+      }
+      else if (ptr == &timer_queues_)
+      {
+        check_timers = true;
+      }
+      else if (ptr == &timeout_)
+      {
+        check_timers = true;
+        timeout_.tv_sec = 0;
+        timeout_.tv_nsec = 0;
+      }
+      else if (ptr == &ts)
+      {
+        --local_ops;
+      }
+      else
+      {
+        io_queue* io_q = static_cast<io_queue*>(ptr);
+        io_q->set_result(cqe->res);
+        ops.push(io_q);
+      }
+    }
+    ::io_uring_cqe_seen(&ring_, cqe);
+    result = (++count < complete_batch_size || local_ops > 0)
+      ? ::io_uring_peek_cqe(&ring_, &cqe) : -EAGAIN;
+  }
+
+  decrement(outstanding_work_, count);
+
+  if (check_timers)
+  {
+    mutex::scoped_lock lock(mutex_);
+    timer_queues_.get_ready_timers(ops);
+    if (timeout_.tv_sec == 0 && timeout_.tv_nsec == 0)
+    {
+      timeout_ = get_timeout();
+      if (::io_uring_sqe* sqe = get_sqe())
+      {
+        ::io_uring_prep_timeout(sqe, &timeout_, 0, 0);
+        ::io_uring_sqe_set_data(sqe, &timeout_);
+        push_submit_sqes_op(ops);
+      }
+    }
+  }
+}
+
+void io_uring_service::interrupt()
+{
+  mutex::scoped_lock lock(mutex_);
+  if (::io_uring_sqe* sqe = get_sqe())
+  {
+    ::io_uring_prep_nop(sqe);
+    ::io_uring_sqe_set_data(sqe, this);
+  }
+  submit_sqes();
+}
+
+void io_uring_service::init_ring()
+{
+  int result = ::io_uring_queue_init(ring_size, &ring_, 0);
+  if (result < 0)
+  {
+    ring_.ring_fd = -1;
+    boost::system::error_code ec(-result,
+        boost::asio::error::get_system_category());
+    boost::asio::detail::throw_error(ec, "io_uring_queue_init");
+  }
+
+#if !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  event_fd_ = ::eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
+  if (event_fd_ < 0)
+  {
+    boost::system::error_code ec(-result,
+        boost::asio::error::get_system_category());
+    ::io_uring_queue_exit(&ring_);
+    boost::asio::detail::throw_error(ec, "eventfd");
+  }
+
+  result = ::io_uring_register_eventfd(&ring_, event_fd_);
+  if (result < 0)
+  {
+    ::close(event_fd_);
+    ::io_uring_queue_exit(&ring_);
+    boost::system::error_code ec(-result,
+        boost::asio::error::get_system_category());
+    boost::asio::detail::throw_error(ec, "io_uring_queue_init");
+  }
+#endif // !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+}
+
+#if !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+class io_uring_service::event_fd_read_op :
+  public reactor_op
+{
+public:
+  event_fd_read_op(io_uring_service* s)
+    : reactor_op(boost::system::error_code(),
+        &event_fd_read_op::do_perform, event_fd_read_op::do_complete),
+      service_(s)
+  {
+  }
+
+  static status do_perform(reactor_op* base)
+  {
+    event_fd_read_op* o(static_cast<event_fd_read_op*>(base));
+
+    for (;;)
+    {
+      // Only perform one read. The kernel maintains an atomic counter.
+      uint64_t counter(0);
+      errno = 0;
+      int bytes_read = ::read(o->service_->event_fd_,
+          &counter, sizeof(uint64_t));
+      if (bytes_read < 0 && errno == EINTR)
+        continue;
+      break;
+    }
+
+    op_queue<operation> ops;
+    o->service_->run(0, ops);
+    o->service_->scheduler_.post_deferred_completions(ops);
+
+    return not_done;
+  }
+
+  static void do_complete(void* /*owner*/, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    event_fd_read_op* o(static_cast<event_fd_read_op*>(base));
+    delete o;
+  }
+
+private:
+  io_uring_service* service_;
+};
+#endif // !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+
+void io_uring_service::register_with_reactor()
+{
+#if !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  reactor_.register_internal_descriptor(reactor::read_op,
+      event_fd_, reactor_data_, new event_fd_read_op(this));
+#endif // !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+}
+
+io_uring_service::io_object* io_uring_service::allocate_io_object()
+{
+  mutex::scoped_lock registration_lock(registration_mutex_);
+  return registered_io_objects_.alloc(
+      BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING(
+        REACTOR_IO, scheduler_.concurrency_hint()));
+}
+
+void io_uring_service::free_io_object(io_uring_service::io_object* io_obj)
+{
+  mutex::scoped_lock registration_lock(registration_mutex_);
+  registered_io_objects_.free(io_obj);
+}
+
+void io_uring_service::do_cancel_ops(
+    per_io_object_data& io_obj, op_queue<operation>& ops)
+{
+  bool cancel_op = false;
+
+  for (int i = 0; i < max_ops; ++i)
+  {
+    if (io_uring_operation* first_op = io_obj->queues_[i].op_queue_.front())
+    {
+      cancel_op = true;
+      io_obj->queues_[i].op_queue_.pop();
+      while (io_uring_operation* op = io_obj->queues_[i].op_queue_.front())
+      {
+        op->ec_ = boost::asio::error::operation_aborted;
+        io_obj->queues_[i].op_queue_.pop();
+        ops.push(op);
+      }
+      io_obj->queues_[i].op_queue_.push(first_op);
+    }
+  }
+
+  if (cancel_op)
+  {
+    mutex::scoped_lock lock(mutex_);
+    for (int i = 0; i < max_ops; ++i)
+    {
+      if (!io_obj->queues_[i].op_queue_.empty()
+          && !io_obj->queues_[i].cancel_requested_)
+      {
+        io_obj->queues_[i].cancel_requested_ = true;
+        if (::io_uring_sqe* sqe = get_sqe())
+          ::io_uring_prep_cancel(sqe, &io_obj->queues_[i], 0);
+      }
+    }
+    submit_sqes();
+  }
+}
+
+void io_uring_service::do_add_timer_queue(timer_queue_base& queue)
+{
+  mutex::scoped_lock lock(mutex_);
+  timer_queues_.insert(&queue);
+}
+
+void io_uring_service::do_remove_timer_queue(timer_queue_base& queue)
+{
+  mutex::scoped_lock lock(mutex_);
+  timer_queues_.erase(&queue);
+}
+
+void io_uring_service::update_timeout()
+{
+  if (::io_uring_sqe* sqe = get_sqe())
+  {
+    ::io_uring_prep_timeout_remove(sqe, reinterpret_cast<__u64>(&timeout_), 0);
+    ::io_uring_sqe_set_data(sqe, &timer_queues_);
+  }
+}
+
+__kernel_timespec io_uring_service::get_timeout() const
+{
+  __kernel_timespec ts;
+  long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
+  ts.tv_sec = usec / 1000000;
+  ts.tv_nsec = usec ? (usec % 1000000) * 1000 : 1;
+  return ts;
+}
+
+::io_uring_sqe* io_uring_service::get_sqe()
+{
+  ::io_uring_sqe* sqe = ::io_uring_get_sqe(&ring_);
+  if (!sqe)
+  {
+    submit_sqes();
+    sqe = ::io_uring_get_sqe(&ring_);
+  }
+  if (sqe)
+    ++pending_sqes_;
+  return sqe;
+}
+
+void io_uring_service::submit_sqes()
+{
+  if (pending_sqes_ != 0)
+  {
+    int result = ::io_uring_submit(&ring_);
+    if (result > 0)
+    {
+      pending_sqes_ -= result;
+      increment(outstanding_work_, result);
+    }
+  }
+}
+
+void io_uring_service::post_submit_sqes_op(mutex::scoped_lock& lock)
+{
+  if (pending_sqes_ >= submit_batch_size)
+  {
+    submit_sqes();
+  }
+  else if (pending_sqes_ != 0 && !pending_submit_sqes_op_)
+  {
+    pending_submit_sqes_op_ = true;
+    lock.unlock();
+    scheduler_.post_immediate_completion(&submit_sqes_op_, false);
+  }
+}
+
+void io_uring_service::push_submit_sqes_op(op_queue<operation>& ops)
+{
+  if (pending_sqes_ != 0 && !pending_submit_sqes_op_)
+  {
+    pending_submit_sqes_op_ = true;
+    ops.push(&submit_sqes_op_);
+    scheduler_.compensating_work_started();
+  }
+}
+
+io_uring_service::submit_sqes_op::submit_sqes_op(io_uring_service* s)
+  : operation(&io_uring_service::submit_sqes_op::do_complete),
+    service_(s)
+{
+}
+
+void io_uring_service::submit_sqes_op::do_complete(void* owner, operation* base,
+    const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/)
+{
+  if (owner)
+  {
+    submit_sqes_op* o = static_cast<submit_sqes_op*>(base);
+    mutex::scoped_lock lock(o->service_->mutex_);
+    o->service_->submit_sqes();
+    if (o->service_->pending_sqes_ != 0)
+      o->service_->scheduler_.post_immediate_completion(o, true);
+    else
+      o->service_->pending_submit_sqes_op_ = false;
+  }
+}
+
+io_uring_service::io_queue::io_queue()
+  : operation(&io_uring_service::io_queue::do_complete)
+{
+}
+
+struct io_uring_service::perform_io_cleanup_on_block_exit
+{
+  explicit perform_io_cleanup_on_block_exit(io_uring_service* s)
+    : service_(s), first_op_(0)
+  {
+  }
+
+  ~perform_io_cleanup_on_block_exit()
+  {
+    if (first_op_)
+    {
+      // Post the remaining completed operations for invocation.
+      if (!ops_.empty())
+        service_->scheduler_.post_deferred_completions(ops_);
+
+      // A user-initiated operation has completed, but there's no need to
+      // explicitly call work_finished() here. Instead, we'll take advantage of
+      // the fact that the scheduler will call work_finished() once we return.
+    }
+    else
+    {
+      // No user-initiated operations have completed, so we need to compensate
+      // for the work_finished() call that the scheduler will make once this
+      // operation returns.
+      service_->scheduler_.compensating_work_started();
+    }
+  }
+
+  io_uring_service* service_;
+  op_queue<operation> ops_;
+  operation* first_op_;
+};
+
+operation* io_uring_service::io_queue::perform_io(int result)
+{
+  perform_io_cleanup_on_block_exit io_cleanup(io_object_->service_);
+  mutex::scoped_lock io_object_lock(io_object_->mutex_);
+
+  if (result != -ECANCELED || cancel_requested_)
+  {
+    if (io_uring_operation* op = op_queue_.front())
+    {
+      if (result < 0)
+      {
+        op->ec_.assign(-result, boost::asio::error::get_system_category());
+        op->bytes_transferred_ = 0;
+      }
+      else
+      {
+        op->ec_.assign(0, op->ec_.category());
+        op->bytes_transferred_ = static_cast<std::size_t>(result);
+      }
+    }
+
+    while (io_uring_operation* op = op_queue_.front())
+    {
+      if (op->perform(io_cleanup.ops_.empty()))
+      {
+        op_queue_.pop();
+        io_cleanup.ops_.push(op);
+      }
+      else
+        break;
+    }
+  }
+
+  cancel_requested_ = false;
+
+  if (!op_queue_.empty())
+  {
+    io_uring_service* service = io_object_->service_;
+    mutex::scoped_lock lock(service->mutex_);
+    if (::io_uring_sqe* sqe = service->get_sqe())
+    {
+      op_queue_.front()->prepare(sqe);
+      ::io_uring_sqe_set_data(sqe, this);
+      service->post_submit_sqes_op(lock);
+    }
+    else
+    {
+      lock.unlock();
+      while (io_uring_operation* op = op_queue_.front())
+      {
+        op->ec_ = boost::asio::error::no_buffer_space;
+        op_queue_.pop();
+        io_cleanup.ops_.push(op);
+      }
+    }
+  }
+
+  // The first operation will be returned for completion now. The others will
+  // be posted for later by the io_cleanup object's destructor.
+  io_cleanup.first_op_ = io_cleanup.ops_.front();
+  io_cleanup.ops_.pop();
+  return io_cleanup.first_op_;
+}
+
+void io_uring_service::io_queue::do_complete(void* owner, operation* base,
+    const boost::system::error_code& ec, std::size_t bytes_transferred)
+{
+  if (owner)
+  {
+    io_queue* io_q = static_cast<io_queue*>(base);
+    int result = static_cast<int>(bytes_transferred);
+    if (operation* op = io_q->perform_io(result))
+    {
+      op->complete(owner, ec, 0);
+    }
+  }
+}
+
+io_uring_service::io_object::io_object(bool locking)
+  : mutex_(locking)
+{
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_IO_URING_SERVICE_IPP
diff --git a/boost/asio/detail/impl/io_uring_socket_service_base.ipp b/boost/asio/detail/impl/io_uring_socket_service_base.ipp
new file mode 100644
index 0000000000000000000000000000000000000000..7bad2405a5ca9fe7c45d8dd70bf7f1c290ab8a6d
--- /dev/null
+++ b/boost/asio/detail/impl/io_uring_socket_service_base.ipp
@@ -0,0 +1,251 @@
+//
+// detail/io_uring_socket_service_base.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IMPL_IO_URING_SOCKET_SERVICE_BASE_IPP
+#define BOOST_ASIO_DETAIL_IMPL_IO_URING_SOCKET_SERVICE_BASE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/detail/io_uring_socket_service_base.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+io_uring_socket_service_base::io_uring_socket_service_base(
+    execution_context& context)
+  : io_uring_service_(boost::asio::use_service<io_uring_service>(context))
+{
+  io_uring_service_.init_task();
+}
+
+void io_uring_socket_service_base::base_shutdown()
+{
+}
+
+void io_uring_socket_service_base::construct(
+    io_uring_socket_service_base::base_implementation_type& impl)
+{
+  impl.socket_ = invalid_socket;
+  impl.state_ = 0;
+  impl.io_object_data_ = 0;
+}
+
+void io_uring_socket_service_base::base_move_construct(
+    io_uring_socket_service_base::base_implementation_type& impl,
+    io_uring_socket_service_base::base_implementation_type& other_impl)
+  BOOST_ASIO_NOEXCEPT
+{
+  impl.socket_ = other_impl.socket_;
+  other_impl.socket_ = invalid_socket;
+
+  impl.state_ = other_impl.state_;
+  other_impl.state_ = 0;
+
+  impl.io_object_data_ = other_impl.io_object_data_;
+  other_impl.io_object_data_ = 0;
+}
+
+void io_uring_socket_service_base::base_move_assign(
+    io_uring_socket_service_base::base_implementation_type& impl,
+    io_uring_socket_service_base& /*other_service*/,
+    io_uring_socket_service_base::base_implementation_type& other_impl)
+{
+  destroy(impl);
+
+  impl.socket_ = other_impl.socket_;
+  other_impl.socket_ = invalid_socket;
+
+  impl.state_ = other_impl.state_;
+  other_impl.state_ = 0;
+
+  impl.io_object_data_ = other_impl.io_object_data_;
+  other_impl.io_object_data_ = 0;
+}
+
+void io_uring_socket_service_base::destroy(
+    io_uring_socket_service_base::base_implementation_type& impl)
+{
+  if (impl.socket_ != invalid_socket)
+  {
+    BOOST_ASIO_HANDLER_OPERATION((io_uring_service_.context(),
+          "socket", &impl, impl.socket_, "close"));
+
+    io_uring_service_.deregister_io_object(impl.io_object_data_);
+    boost::system::error_code ignored_ec;
+    socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
+    io_uring_service_.cleanup_io_object(impl.io_object_data_);
+  }
+}
+
+boost::system::error_code io_uring_socket_service_base::close(
+    io_uring_socket_service_base::base_implementation_type& impl,
+    boost::system::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    BOOST_ASIO_HANDLER_OPERATION((io_uring_service_.context(),
+          "socket", &impl, impl.socket_, "close"));
+
+    io_uring_service_.deregister_io_object(impl.io_object_data_);
+    socket_ops::close(impl.socket_, impl.state_, false, ec);
+    io_uring_service_.cleanup_io_object(impl.io_object_data_);
+  }
+  else
+  {
+    ec = success_ec_;
+  }
+
+  // The descriptor is closed by the OS even if close() returns an error.
+  //
+  // (Actually, POSIX says the state of the descriptor is unspecified. On
+  // Linux the descriptor is apparently closed anyway; e.g. see
+  //   http://lkml.org/lkml/2005/9/10/129
+  construct(impl);
+
+  return ec;
+}
+
+socket_type io_uring_socket_service_base::release(
+    io_uring_socket_service_base::base_implementation_type& impl,
+    boost::system::error_code& ec)
+{
+  if (!is_open(impl))
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return invalid_socket;
+  }
+
+  BOOST_ASIO_HANDLER_OPERATION((io_uring_service_.context(),
+        "socket", &impl, impl.socket_, "release"));
+
+  io_uring_service_.deregister_io_object(impl.io_object_data_);
+  io_uring_service_.cleanup_io_object(impl.io_object_data_);
+  socket_type sock = impl.socket_;
+  construct(impl);
+  ec = success_ec_;
+  return sock;
+}
+
+boost::system::error_code io_uring_socket_service_base::cancel(
+    io_uring_socket_service_base::base_implementation_type& impl,
+    boost::system::error_code& ec)
+{
+  if (!is_open(impl))
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return ec;
+  }
+
+  BOOST_ASIO_HANDLER_OPERATION((io_uring_service_.context(),
+        "socket", &impl, impl.socket_, "cancel"));
+
+  io_uring_service_.cancel_ops(impl.io_object_data_);
+  ec = success_ec_;
+  return ec;
+}
+
+boost::system::error_code io_uring_socket_service_base::do_open(
+    io_uring_socket_service_base::base_implementation_type& impl,
+    int af, int type, int protocol, boost::system::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    ec = boost::asio::error::already_open;
+    return ec;
+  }
+
+  socket_holder sock(socket_ops::socket(af, type, protocol, ec));
+  if (sock.get() == invalid_socket)
+    return ec;
+
+  io_uring_service_.register_io_object(impl.io_object_data_);
+
+  impl.socket_ = sock.release();
+  switch (type)
+  {
+  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
+  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
+  default: impl.state_ = 0; break;
+  }
+  ec = success_ec_;
+  return ec;
+}
+
+boost::system::error_code io_uring_socket_service_base::do_assign(
+    io_uring_socket_service_base::base_implementation_type& impl, int type,
+    const io_uring_socket_service_base::native_handle_type& native_socket,
+    boost::system::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    ec = boost::asio::error::already_open;
+    return ec;
+  }
+
+  io_uring_service_.register_io_object(impl.io_object_data_);
+
+  impl.socket_ = native_socket;
+  switch (type)
+  {
+  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
+  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
+  default: impl.state_ = 0; break;
+  }
+  impl.state_ |= socket_ops::possible_dup;
+  ec = success_ec_;
+  return ec;
+}
+
+void io_uring_socket_service_base::start_op(
+    io_uring_socket_service_base::base_implementation_type& impl,
+    int op_type, io_uring_operation* op, bool is_continuation, bool noop)
+{
+  if (!noop)
+  {
+    io_uring_service_.start_op(op_type,
+        impl.io_object_data_, op, is_continuation);
+  }
+  else
+  {
+    io_uring_service_.post_immediate_completion(op, is_continuation);
+  }
+}
+
+void io_uring_socket_service_base::start_accept_op(
+    io_uring_socket_service_base::base_implementation_type& impl,
+    io_uring_operation* op, bool is_continuation, bool peer_is_open)
+{
+  if (!peer_is_open)
+    start_op(impl, io_uring_service::read_op, op, is_continuation, false);
+  else
+  {
+    op->ec_ = boost::asio::error::already_open;
+    io_uring_service_.post_immediate_completion(op, is_continuation);
+  }
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_IO_URING_SOCKET_SERVICE_BASE_IPP
diff --git a/boost/asio/detail/impl/kqueue_reactor.hpp b/boost/asio/detail/impl/kqueue_reactor.hpp
index fa6db9b9f7e7f5b5a8123d10cbca38248f596ef7..8d302b6e6844ed12db451573623ac56f7d650925 100644
--- a/boost/asio/detail/impl/kqueue_reactor.hpp
+++ b/boost/asio/detail/impl/kqueue_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/impl/kqueue_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2005 Stefan Arentz (stefan at soze dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -20,12 +20,20 @@
 
 #if defined(BOOST_ASIO_HAS_KQUEUE)
 
+#include <boost/asio/detail/scheduler.hpp>
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
+inline void kqueue_reactor::post_immediate_completion(
+    operation* op, bool is_continuation)
+{
+  scheduler_.post_immediate_completion(op, is_continuation);
+}
+
 template <typename Time_Traits>
 void kqueue_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
 {
@@ -71,6 +79,18 @@ std::size_t kqueue_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
   return n;
 }
 
+template <typename Time_Traits>
+void kqueue_reactor::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data* timer,
+    void* cancellation_key)
+{
+  mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  queue.cancel_timer_by_key(timer, ops, cancellation_key);
+  lock.unlock();
+  scheduler_.post_deferred_completions(ops);
+}
+
 template <typename Time_Traits>
 void kqueue_reactor::move_timer(timer_queue<Time_Traits>& queue,
     typename timer_queue<Time_Traits>::per_timer_data& target,
diff --git a/boost/asio/detail/impl/kqueue_reactor.ipp b/boost/asio/detail/impl/kqueue_reactor.ipp
index fe24cf8f71f7d31dd55df925c486153a875fed9e..c710a2789dda2f1d3107806e0461471ee6707343 100644
--- a/boost/asio/detail/impl/kqueue_reactor.ipp
+++ b/boost/asio/detail/impl/kqueue_reactor.ipp
@@ -2,7 +2,7 @@
 // detail/impl/kqueue_reactor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2005 Stefan Arentz (stefan at soze dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -287,6 +287,35 @@ void kqueue_reactor::cancel_ops(socket_type,
   scheduler_.post_deferred_completions(ops);
 }
 
+void kqueue_reactor::cancel_ops_by_key(socket_type,
+    kqueue_reactor::per_descriptor_data& descriptor_data,
+    int op_type, void* cancellation_key)
+{
+  if (!descriptor_data)
+    return;
+
+  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+
+  op_queue<operation> ops;
+  op_queue<reactor_op> other_ops;
+  while (reactor_op* op = descriptor_data->op_queue_[op_type].front())
+  {
+    descriptor_data->op_queue_[op_type].pop();
+    if (op->cancellation_key_ == cancellation_key)
+    {
+      op->ec_ = boost::asio::error::operation_aborted;
+      ops.push(op);
+    }
+    else
+      other_ops.push(op);
+  }
+  descriptor_data->op_queue_[op_type].push(other_ops);
+
+  descriptor_lock.unlock();
+
+  scheduler_.post_deferred_completions(ops);
+}
+
 void kqueue_reactor::deregister_descriptor(socket_type descriptor,
     kqueue_reactor::per_descriptor_data& descriptor_data, bool closing)
 {
diff --git a/boost/asio/detail/impl/null_event.ipp b/boost/asio/detail/impl/null_event.ipp
index e36344d5d3ca76f4f5a240c7b8596fba8681cce5..723bd85903467c0fc564b2c4463a87651c58c73e 100644
--- a/boost/asio/detail/impl/null_event.ipp
+++ b/boost/asio/detail/impl/null_event.ipp
@@ -2,7 +2,7 @@
 // detail/impl/null_event.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/pipe_select_interrupter.ipp b/boost/asio/detail/impl/pipe_select_interrupter.ipp
index f11af1a9deb3a58d040ae783bf85e77a7c599e8d..dc894eb796971894bcaa34d60e24f4f456faa535 100644
--- a/boost/asio/detail/impl/pipe_select_interrupter.ipp
+++ b/boost/asio/detail/impl/pipe_select_interrupter.ipp
@@ -2,7 +2,7 @@
 // detail/impl/pipe_select_interrupter.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/posix_event.ipp b/boost/asio/detail/impl/posix_event.ipp
index fc6c86d527d6be2f216b0e73af57409b7e37317c..e987f09366fda1412a2f7645f84bd64998a6e11f 100644
--- a/boost/asio/detail/impl/posix_event.ipp
+++ b/boost/asio/detail/impl/posix_event.ipp
@@ -2,7 +2,7 @@
 // detail/impl/posix_event.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/posix_mutex.ipp b/boost/asio/detail/impl/posix_mutex.ipp
index 82429aee9446b8d24b7c444775998406ef91e7ae..507c91d1afa38faf3a81fdc68282f8f76cda393e 100644
--- a/boost/asio/detail/impl/posix_mutex.ipp
+++ b/boost/asio/detail/impl/posix_mutex.ipp
@@ -2,7 +2,7 @@
 // detail/impl/posix_mutex.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/posix_serial_port_service.ipp b/boost/asio/detail/impl/posix_serial_port_service.ipp
new file mode 100644
index 0000000000000000000000000000000000000000..ff8fa27fed7ac496ed0787eae6bf68f63e644b07
--- /dev/null
+++ b/boost/asio/detail/impl/posix_serial_port_service.ipp
@@ -0,0 +1,151 @@
+//
+// detail/impl/posix_serial_port_service.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IMPL_POSIX_SERIAL_PORT_SERVICE_IPP
+#define BOOST_ASIO_DETAIL_IMPL_POSIX_SERIAL_PORT_SERVICE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_SERIAL_PORT)
+#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
+
+#include <cstring>
+#include <boost/asio/detail/posix_serial_port_service.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+posix_serial_port_service::posix_serial_port_service(
+    execution_context& context)
+  : execution_context_service_base<posix_serial_port_service>(context),
+    descriptor_service_(context)
+{
+}
+
+void posix_serial_port_service::shutdown()
+{
+  descriptor_service_.shutdown();
+}
+
+boost::system::error_code posix_serial_port_service::open(
+    posix_serial_port_service::implementation_type& impl,
+    const std::string& device, boost::system::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    ec = boost::asio::error::already_open;
+    return ec;
+  }
+
+  descriptor_ops::state_type state = 0;
+  int fd = descriptor_ops::open(device.c_str(),
+      O_RDWR | O_NONBLOCK | O_NOCTTY, ec);
+  if (fd < 0)
+    return ec;
+
+  int s = descriptor_ops::fcntl(fd, F_GETFL, ec);
+  if (s >= 0)
+    s = descriptor_ops::fcntl(fd, F_SETFL, s | O_NONBLOCK, ec);
+  if (s < 0)
+  {
+    boost::system::error_code ignored_ec;
+    descriptor_ops::close(fd, state, ignored_ec);
+    return ec;
+  }
+
+  // Set up default serial port options.
+  termios ios;
+  s = ::tcgetattr(fd, &ios);
+  descriptor_ops::get_last_error(ec, s < 0);
+  if (s >= 0)
+  {
+#if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
+    ::cfmakeraw(&ios);
+#else
+    ios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK
+        | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
+    ios.c_oflag &= ~OPOST;
+    ios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
+    ios.c_cflag &= ~(CSIZE | PARENB);
+    ios.c_cflag |= CS8;
+#endif
+    ios.c_iflag |= IGNPAR;
+    ios.c_cflag |= CREAD | CLOCAL;
+    s = ::tcsetattr(fd, TCSANOW, &ios);
+    descriptor_ops::get_last_error(ec, s < 0);
+  }
+  if (s < 0)
+  {
+    boost::system::error_code ignored_ec;
+    descriptor_ops::close(fd, state, ignored_ec);
+    return ec;
+  }
+
+  // We're done. Take ownership of the serial port descriptor.
+  if (descriptor_service_.assign(impl, fd, ec))
+  {
+    boost::system::error_code ignored_ec;
+    descriptor_ops::close(fd, state, ignored_ec);
+  }
+
+  return ec;
+}
+
+boost::system::error_code posix_serial_port_service::do_set_option(
+    posix_serial_port_service::implementation_type& impl,
+    posix_serial_port_service::store_function_type store,
+    const void* option, boost::system::error_code& ec)
+{
+  termios ios;
+  int s = ::tcgetattr(descriptor_service_.native_handle(impl), &ios);
+  descriptor_ops::get_last_error(ec, s < 0);
+  if (s < 0)
+    return ec;
+
+  if (store(option, ios, ec))
+    return ec;
+
+  s = ::tcsetattr(descriptor_service_.native_handle(impl), TCSANOW, &ios);
+  descriptor_ops::get_last_error(ec, s < 0);
+  return ec;
+}
+
+boost::system::error_code posix_serial_port_service::do_get_option(
+    const posix_serial_port_service::implementation_type& impl,
+    posix_serial_port_service::load_function_type load,
+    void* option, boost::system::error_code& ec) const
+{
+  termios ios;
+  int s = ::tcgetattr(descriptor_service_.native_handle(impl), &ios);
+  descriptor_ops::get_last_error(ec, s < 0);
+  if (s < 0)
+    return ec;
+
+  return load(option, ios, ec);
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_HAS_SERIAL_PORT)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_POSIX_SERIAL_PORT_SERVICE_IPP
diff --git a/boost/asio/detail/impl/posix_thread.ipp b/boost/asio/detail/impl/posix_thread.ipp
index 4193302dcb4e55d2c18a7d3cef99385471af4174..3f034c3d520de434d431ac0fd690fa4db9fbdd5a 100644
--- a/boost/asio/detail/impl/posix_thread.ipp
+++ b/boost/asio/detail/impl/posix_thread.ipp
@@ -2,7 +2,7 @@
 // detail/impl/posix_thread.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/posix_tss_ptr.ipp b/boost/asio/detail/impl/posix_tss_ptr.ipp
index 1d94dc15d2d6b3ed95765d37060473ad5440d7d5..7b26dc3a684d6ec9003d0869f1a8350ac2e51172 100644
--- a/boost/asio/detail/impl/posix_tss_ptr.ipp
+++ b/boost/asio/detail/impl/posix_tss_ptr.ipp
@@ -2,7 +2,7 @@
 // detail/impl/posix_tss_ptr.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/reactive_descriptor_service.ipp b/boost/asio/detail/impl/reactive_descriptor_service.ipp
index d46a92bb8d01de9f2427e7aa06d14c413f6da0c0..e61bcc1a38ef62583b48764b122629ae21f51228 100644
--- a/boost/asio/detail/impl/reactive_descriptor_service.ipp
+++ b/boost/asio/detail/impl/reactive_descriptor_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/reactive_descriptor_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,7 +19,8 @@
 
 #if !defined(BOOST_ASIO_WINDOWS) \
   && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
+  && !defined(__CYGWIN__) \
+  && !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
 #include <boost/asio/error.hpp>
 #include <boost/asio/detail/reactive_descriptor_service.hpp>
@@ -221,5 +222,6 @@ void reactive_descriptor_service::start_op(
 #endif // !defined(BOOST_ASIO_WINDOWS)
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
        //   && !defined(__CYGWIN__)
+       //   && !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP
diff --git a/boost/asio/detail/impl/reactive_socket_service_base.ipp b/boost/asio/detail/impl/reactive_socket_service_base.ipp
index 19e1049c498cc7609a15e7eae975496f8f6fdca2..e2ba10613bbec7a4dcbed8514558268dcaebf0a6 100644
--- a/boost/asio/detail/impl/reactive_socket_service_base.ipp
+++ b/boost/asio/detail/impl/reactive_socket_service_base.ipp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_service_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,7 +18,8 @@
 #include <boost/asio/detail/config.hpp>
 
 #if !defined(BOOST_ASIO_HAS_IOCP) \
-  && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
 #include <boost/asio/detail/reactive_socket_service_base.hpp>
 
@@ -298,5 +299,6 @@ void reactive_socket_service_base::start_connect_op(
 
 #endif // !defined(BOOST_ASIO_HAS_IOCP)
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP
diff --git a/boost/asio/detail/impl/resolver_service_base.ipp b/boost/asio/detail/impl/resolver_service_base.ipp
index daf3fb0addbb2f5b45c8fcddc9151211ec8810f3..df22ee1ddb0d539ff070a76ab40c7a38b7e71df5 100644
--- a/boost/asio/detail/impl/resolver_service_base.ipp
+++ b/boost/asio/detail/impl/resolver_service_base.ipp
@@ -2,7 +2,7 @@
 // detail/impl/resolver_service_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/scheduler.ipp b/boost/asio/detail/impl/scheduler.ipp
index 089e36e8e84d2a88e39e1968a6bce5b9b792c2ca..0ebc5599261e763f757762b28bc76ece83b5fcbb 100644
--- a/boost/asio/detail/impl/scheduler.ipp
+++ b/boost/asio/detail/impl/scheduler.ipp
@@ -2,7 +2,7 @@
 // detail/impl/scheduler.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,11 +20,16 @@
 #include <boost/asio/detail/concurrency_hint.hpp>
 #include <boost/asio/detail/event.hpp>
 #include <boost/asio/detail/limits.hpp>
-#include <boost/asio/detail/reactor.hpp>
 #include <boost/asio/detail/scheduler.hpp>
 #include <boost/asio/detail/scheduler_thread_info.hpp>
 #include <boost/asio/detail/signal_blocker.hpp>
 
+#if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/io_uring_service.hpp>
+#else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/reactor.hpp>
+#endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -105,7 +110,7 @@ struct scheduler::work_cleanup
 };
 
 scheduler::scheduler(boost::asio::execution_context& ctx,
-    int concurrency_hint, bool own_thread)
+    int concurrency_hint, bool own_thread, get_task_func_type get_task)
   : boost::asio::detail::execution_context_service_base<scheduler>(ctx),
     one_thread_(concurrency_hint == 1
         || !BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING(
@@ -115,6 +120,7 @@ scheduler::scheduler(boost::asio::execution_context& ctx,
     mutex_(BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING(
           SCHEDULER, concurrency_hint)),
     task_(0),
+    get_task_(get_task),
     task_interrupted_(true),
     outstanding_work_(0),
     stopped_(false),
@@ -179,7 +185,7 @@ void scheduler::init_task()
   mutex::scoped_lock lock(mutex_);
   if (!shutdown_ && !task_)
   {
-    task_ = &use_service<reactor>(this->context());
+    task_ = get_task_(this->context());
     op_queue_.push(&task_operation_);
     wake_one_thread_and_unlock(lock);
   }
@@ -652,6 +658,15 @@ void scheduler::wake_one_thread_and_unlock(
   }
 }
 
+scheduler_task* scheduler::get_default_task(boost::asio::execution_context& ctx)
+{
+#if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  return &use_service<io_uring_service>(ctx);
+#else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  return &use_service<reactor>(ctx);
+#endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+}
+
 } // namespace detail
 } // namespace asio
 } // namespace boost
diff --git a/boost/asio/detail/impl/select_reactor.hpp b/boost/asio/detail/impl/select_reactor.hpp
index 57c8137a4241a52636b1f045a7be07a0c8c8456b..187cb852528441ff16483e9cec1bee35b97e1bd8 100644
--- a/boost/asio/detail/impl/select_reactor.hpp
+++ b/boost/asio/detail/impl/select_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/impl/select_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -23,12 +23,24 @@
       && !defined(BOOST_ASIO_HAS_KQUEUE) \
       && !defined(BOOST_ASIO_WINDOWS_RUNTIME))
 
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/win_iocp_io_context.hpp>
+#else // defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/scheduler.hpp>
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
+inline void select_reactor::post_immediate_completion(
+    reactor_op* op, bool is_continuation)
+{
+  scheduler_.post_immediate_completion(op, is_continuation);
+}
+
 template <typename Time_Traits>
 void select_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
 {
@@ -74,6 +86,18 @@ std::size_t select_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
   return n;
 }
 
+template <typename Time_Traits>
+void select_reactor::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data* timer,
+    void* cancellation_key)
+{
+  mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  queue.cancel_timer_by_key(timer, ops, cancellation_key);
+  lock.unlock();
+  scheduler_.post_deferred_completions(ops);
+}
+
 template <typename Time_Traits>
 void select_reactor::move_timer(timer_queue<Time_Traits>& queue,
     typename timer_queue<Time_Traits>::per_timer_data& target,
diff --git a/boost/asio/detail/impl/select_reactor.ipp b/boost/asio/detail/impl/select_reactor.ipp
index 1e2fff4abf49179d98bdb1653cf77f33226fe895..80d8903604886e56a3c6c06d576f6e75dc86d002 100644
--- a/boost/asio/detail/impl/select_reactor.ipp
+++ b/boost/asio/detail/impl/select_reactor.ipp
@@ -2,7 +2,7 @@
 // detail/impl/select_reactor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -28,6 +28,12 @@
 #include <boost/asio/detail/signal_blocker.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/win_iocp_io_context.hpp>
+#else // defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/scheduler.hpp>
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -166,6 +172,19 @@ void select_reactor::cancel_ops(socket_type descriptor,
   cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted);
 }
 
+void select_reactor::cancel_ops_by_key(socket_type descriptor,
+    select_reactor::per_descriptor_data&,
+    int op_type, void* cancellation_key)
+{
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  bool need_interrupt = op_queue_[op_type].cancel_operations_by_key(
+      descriptor, ops, cancellation_key, boost::asio::error::operation_aborted);
+  scheduler_.post_deferred_completions(ops);
+  if (need_interrupt)
+    interrupter_.interrupt();
+}
+
 void select_reactor::deregister_descriptor(socket_type descriptor,
     select_reactor::per_descriptor_data&, bool)
 {
diff --git a/boost/asio/detail/impl/service_registry.hpp b/boost/asio/detail/impl/service_registry.hpp
index 305786bdf7fb601c68aa34c6a8a5bd797f94b74f..d2b9b9880ec2eeaafd704c4d3384eab8d6d81891 100644
--- a/boost/asio/detail/impl/service_registry.hpp
+++ b/boost/asio/detail/impl/service_registry.hpp
@@ -2,7 +2,7 @@
 // detail/impl/service_registry.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/service_registry.ipp b/boost/asio/detail/impl/service_registry.ipp
index f5f1b4406410fe13742b23dfd05be95009228430..914b73e05da926400ca9ed539d69f8ce9834dfc3 100644
--- a/boost/asio/detail/impl/service_registry.ipp
+++ b/boost/asio/detail/impl/service_registry.ipp
@@ -2,7 +2,7 @@
 // detail/impl/service_registry.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/signal_set_service.ipp b/boost/asio/detail/impl/signal_set_service.ipp
index f9f6d4594054068cad6b9b74acee1a5246a05110..c9061ee96fe963d5dffc87e0cfb474c5241d6c9f 100644
--- a/boost/asio/detail/impl/signal_set_service.ipp
+++ b/boost/asio/detail/impl/signal_set_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/signal_set_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,12 +19,17 @@
 
 #include <cstring>
 #include <stdexcept>
-#include <boost/asio/detail/reactor.hpp>
 #include <boost/asio/detail/signal_blocker.hpp>
 #include <boost/asio/detail/signal_set_service.hpp>
 #include <boost/asio/detail/static_mutex.hpp>
 #include <boost/asio/detail/throw_exception.hpp>
 
+#if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/io_uring_service.hpp>
+#else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/reactor.hpp>
+#endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -86,9 +91,42 @@ void boost_asio_signal_handler(int signal_number)
 #if !defined(BOOST_ASIO_WINDOWS) \
   && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
   && !defined(__CYGWIN__)
-class signal_set_service::pipe_read_op : public reactor_op
+class signal_set_service::pipe_read_op :
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  public io_uring_operation
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  public reactor_op
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 {
 public:
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  pipe_read_op()
+    : io_uring_operation(boost::system::error_code(), &pipe_read_op::do_prepare,
+        &pipe_read_op::do_perform, pipe_read_op::do_complete)
+  {
+  }
+
+  static void do_prepare(io_uring_operation*, ::io_uring_sqe* sqe)
+  {
+    signal_state* state = get_signal_state();
+
+    int fd = state->read_descriptor_;
+    ::io_uring_prep_poll_add(sqe, fd, POLLIN);
+  }
+
+  static bool do_perform(io_uring_operation*, bool)
+  {
+    signal_state* state = get_signal_state();
+
+    int fd = state->read_descriptor_;
+    int signal_number = 0;
+    while (::read(fd, &signal_number, sizeof(int)) == sizeof(int))
+      if (signal_number >= 0 && signal_number < max_signal_number)
+        signal_set_service::deliver_signal(signal_number);
+
+    return false;
+  }
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
   pipe_read_op()
     : reactor_op(boost::system::error_code(),
         &pipe_read_op::do_perform, pipe_read_op::do_complete)
@@ -107,6 +145,7 @@ public:
 
     return not_done;
   }
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
   static void do_complete(void* /*owner*/, operation* base,
       const boost::system::error_code& /*ec*/,
@@ -126,7 +165,11 @@ signal_set_service::signal_set_service(execution_context& context)
 #if !defined(BOOST_ASIO_WINDOWS) \
   && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
   && !defined(__CYGWIN__)
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+    io_uring_service_(boost::asio::use_service<io_uring_service>(context)),
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
     reactor_(boost::asio::use_service<reactor>(context)),
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 #endif // !defined(BOOST_ASIO_WINDOWS)
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
        //   && !defined(__CYGWIN__)
@@ -138,7 +181,11 @@ signal_set_service::signal_set_service(execution_context& context)
 #if !defined(BOOST_ASIO_WINDOWS) \
   && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
   && !defined(__CYGWIN__)
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  io_uring_service_.init_task();
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
   reactor_.init_task();
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 #endif // !defined(BOOST_ASIO_WINDOWS)
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
        //   && !defined(__CYGWIN__)
@@ -188,8 +235,14 @@ void signal_set_service::notify_fork(execution_context::fork_event fork_ev)
       int read_descriptor = state->read_descriptor_;
       state->fork_prepared_ = true;
       lock.unlock();
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+      (void)read_descriptor;
+      io_uring_service_.deregister_io_object(io_object_data_);
+      io_uring_service_.cleanup_io_object(io_object_data_);
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
       reactor_.deregister_internal_descriptor(read_descriptor, reactor_data_);
       reactor_.cleanup_descriptor_data(reactor_data_);
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
     }
     break;
   case execution_context::fork_parent:
@@ -198,8 +251,14 @@ void signal_set_service::notify_fork(execution_context::fork_event fork_ev)
       int read_descriptor = state->read_descriptor_;
       state->fork_prepared_ = false;
       lock.unlock();
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+      (void)read_descriptor;
+      io_uring_service_.register_internal_io_object(io_object_data_,
+          io_uring_service::read_op, new pipe_read_op);
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
       reactor_.register_internal_descriptor(reactor::read_op,
           read_descriptor, reactor_data_, new pipe_read_op);
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
     }
     break;
   case execution_context::fork_child:
@@ -211,8 +270,14 @@ void signal_set_service::notify_fork(execution_context::fork_event fork_ev)
       int read_descriptor = state->read_descriptor_;
       state->fork_prepared_ = false;
       lock.unlock();
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+      (void)read_descriptor;
+      io_uring_service_.register_internal_io_object(io_object_data_,
+          io_uring_service::read_op, new pipe_read_op);
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
       reactor_.register_internal_descriptor(reactor::read_op,
           read_descriptor, reactor_data_, new pipe_read_op);
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
     }
     break;
   default:
@@ -463,6 +528,33 @@ boost::system::error_code signal_set_service::cancel(
   return ec;
 }
 
+void signal_set_service::cancel_ops_by_key(
+    signal_set_service::implementation_type& impl, void* cancellation_key)
+{
+  op_queue<operation> ops;
+  {
+    op_queue<signal_op> other_ops;
+    signal_state* state = get_signal_state();
+    static_mutex::scoped_lock lock(state->mutex_);
+
+    while (signal_op* op = impl.queue_.front())
+    {
+      impl.queue_.pop();
+      if (op->cancellation_key_ == cancellation_key)
+      {
+        op->ec_ = boost::asio::error::operation_aborted;
+        ops.push(op);
+      }
+      else
+        other_ops.push(op);
+    }
+
+    impl.queue_.push(other_ops);
+  }
+
+  scheduler_.post_deferred_completions(ops);
+}
+
 void signal_set_service::deliver_signal(int signal_number)
 {
   signal_state* state = get_signal_state();
@@ -539,8 +631,14 @@ void signal_set_service::add_service(signal_set_service* service)
   // Register for pipe readiness notifications.
   int read_descriptor = state->read_descriptor_;
   lock.unlock();
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  (void)read_descriptor;
+  service->io_uring_service_.register_internal_io_object(
+      service->io_object_data_, io_uring_service::read_op, new pipe_read_op);
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
   service->reactor_.register_internal_descriptor(reactor::read_op,
       read_descriptor, service->reactor_data_, new pipe_read_op);
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 #endif // !defined(BOOST_ASIO_WINDOWS)
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
        //   && !defined(__CYGWIN__)
@@ -559,10 +657,17 @@ void signal_set_service::remove_service(signal_set_service* service)
     // Disable the pipe readiness notifications.
     int read_descriptor = state->read_descriptor_;
     lock.unlock();
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+    (void)read_descriptor;
+    service->io_uring_service_.deregister_io_object(service->io_object_data_);
+    service->io_uring_service_.cleanup_io_object(service->io_object_data_);
+    lock.lock();
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
     service->reactor_.deregister_internal_descriptor(
         read_descriptor, service->reactor_data_);
     service->reactor_.cleanup_descriptor_data(service->reactor_data_);
     lock.lock();
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 #endif // !defined(BOOST_ASIO_WINDOWS)
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
        //   && !defined(__CYGWIN__)
diff --git a/boost/asio/detail/impl/socket_ops.ipp b/boost/asio/detail/impl/socket_ops.ipp
index 83bf30f62bf7adfb7e8d78fedd18be419e464ba0..ba4c8c437239a2e3e24051d4626f897c298d9199 100644
--- a/boost/asio/detail/impl/socket_ops.ipp
+++ b/boost/asio/detail/impl/socket_ops.ipp
@@ -2,7 +2,7 @@
 // detail/impl/socket_ops.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -642,7 +642,7 @@ bool sockatmark(socket_type s, boost::system::error_code& ec)
 # endif // defined(ENOTTY)
 #else // defined(SIOCATMARK)
   int value = ::sockatmark(s);
-  get_last_error(ec, result < 0);
+  get_last_error(ec, value < 0);
 #endif // defined(SIOCATMARK)
 
   return ec ? false : value != 0;
diff --git a/boost/asio/detail/impl/socket_select_interrupter.ipp b/boost/asio/detail/impl/socket_select_interrupter.ipp
index d79df6519ae12ec157ed504e2a3b9769741aecb1..6eda2ef5a3d73abc14abb1537ac1d5664ff4a995 100644
--- a/boost/asio/detail/impl/socket_select_interrupter.ipp
+++ b/boost/asio/detail/impl/socket_select_interrupter.ipp
@@ -2,7 +2,7 @@
 // detail/impl/socket_select_interrupter.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/strand_executor_service.hpp b/boost/asio/detail/impl/strand_executor_service.hpp
index 3fdee1646e82f67fea0a5e16db04518a94555258..3c722763b55585d2c5e747e0100d4336e14186f7 100644
--- a/boost/asio/detail/impl/strand_executor_service.hpp
+++ b/boost/asio/detail/impl/strand_executor_service.hpp
@@ -2,7 +2,7 @@
 // detail/impl/strand_executor_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -106,9 +106,11 @@ public:
       if (push_waiting_to_ready(this_->impl_))
       {
         recycling_allocator<void> allocator;
+        executor_type ex = this_->executor_;
         execution::execute(
             boost::asio::prefer(
-              boost::asio::require(this_->executor_,
+              boost::asio::require(
+                BOOST_ASIO_MOVE_CAST(executor_type)(ex),
                 execution::blocking.never),
             execution::allocator(allocator)),
             BOOST_ASIO_MOVE_CAST(invoker)(*this_));
diff --git a/boost/asio/detail/impl/strand_executor_service.ipp b/boost/asio/detail/impl/strand_executor_service.ipp
index bc5b16b077ccb99938c6219153ab633d8b8da19a..70d72e2b809fa44b6dc246e5d881894d5e64a727 100644
--- a/boost/asio/detail/impl/strand_executor_service.ipp
+++ b/boost/asio/detail/impl/strand_executor_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/strand_executor_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/strand_service.hpp b/boost/asio/detail/impl/strand_service.hpp
index 6fcc3bd0708253e5ab28d4e1c768e7ab7a610cae..0b3a8e4d727dfb4e8cd998f1a31636a0f550f63d 100644
--- a/boost/asio/detail/impl/strand_service.hpp
+++ b/boost/asio/detail/impl/strand_service.hpp
@@ -2,7 +2,7 @@
 // detail/impl/strand_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/strand_service.ipp b/boost/asio/detail/impl/strand_service.ipp
index 8ab70c2ddf1756db540fda30e069250268118126..51cb45d53cfcaa3cdf24066f6b3f01c742c0f196 100644
--- a/boost/asio/detail/impl/strand_service.ipp
+++ b/boost/asio/detail/impl/strand_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/strand_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/thread_context.ipp b/boost/asio/detail/impl/thread_context.ipp
index 88c49da113bfa054726cd27d8535ca73a0b4c17b..fcfcc88d7ecd0350072087cedf35f64d74dd9dbb 100644
--- a/boost/asio/detail/impl/thread_context.ipp
+++ b/boost/asio/detail/impl/thread_context.ipp
@@ -2,7 +2,7 @@
 // detail/impl/thread_context.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/throw_error.ipp b/boost/asio/detail/impl/throw_error.ipp
index 7bdfd8b56b30b4024a4882bf06117205d9323a0b..bfaedd97916a0ed547191f68db92cb359dc60e97 100644
--- a/boost/asio/detail/impl/throw_error.ipp
+++ b/boost/asio/detail/impl/throw_error.ipp
@@ -2,7 +2,7 @@
 // detail/impl/throw_error.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/timer_queue_ptime.ipp b/boost/asio/detail/impl/timer_queue_ptime.ipp
index 31297ffcc081665c1bf88003441edc31682fcdf9..b256caec747fc9d4141e08ee497060b97b78856e 100644
--- a/boost/asio/detail/impl/timer_queue_ptime.ipp
+++ b/boost/asio/detail/impl/timer_queue_ptime.ipp
@@ -2,7 +2,7 @@
 // detail/impl/timer_queue_ptime.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -76,6 +76,12 @@ std::size_t timer_queue<time_traits<boost::posix_time::ptime> >::cancel_timer(
   return impl_.cancel_timer(timer, ops, max_cancelled);
 }
 
+void timer_queue<time_traits<boost::posix_time::ptime> >::cancel_timer_by_key(
+    per_timer_data* timer, op_queue<operation>& ops, void* cancellation_key)
+{
+  impl_.cancel_timer_by_key(timer, ops, cancellation_key);
+}
+
 void timer_queue<time_traits<boost::posix_time::ptime> >::move_timer(
     per_timer_data& target, per_timer_data& source)
 {
diff --git a/boost/asio/detail/impl/timer_queue_set.ipp b/boost/asio/detail/impl/timer_queue_set.ipp
index afd3506b7ebafbc502b32da9a46d1df38f6794ca..5d61a4cb918df44dc2c8e2ef690d0300d1e4cd3d 100644
--- a/boost/asio/detail/impl/timer_queue_set.ipp
+++ b/boost/asio/detail/impl/timer_queue_set.ipp
@@ -2,7 +2,7 @@
 // detail/impl/timer_queue_set.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/win_event.ipp b/boost/asio/detail/impl/win_event.ipp
index 67a6ffb3d5f6f169ef20d72b66d7749672e285ca..8245da06e0493ddada53252c99d7638b42969941 100644
--- a/boost/asio/detail/impl/win_event.ipp
+++ b/boost/asio/detail/impl/win_event.ipp
@@ -2,7 +2,7 @@
 // detail/win_event.ipp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/win_iocp_file_service.ipp b/boost/asio/detail/impl/win_iocp_file_service.ipp
new file mode 100644
index 0000000000000000000000000000000000000000..a28e978df31f0d643a055639fce19166f6f7c699
--- /dev/null
+++ b/boost/asio/detail/impl/win_iocp_file_service.ipp
@@ -0,0 +1,254 @@
+//
+// detail/impl/win_iocp_file_service.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_FILE_SERVICE_IPP
+#define BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_FILE_SERVICE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_FILE) \
+  && defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
+
+#include <cstring>
+#include <sys/stat.h>
+#include <boost/asio/detail/win_iocp_file_service.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+win_iocp_file_service::win_iocp_file_service(
+    execution_context& context)
+  : execution_context_service_base<win_iocp_file_service>(context),
+    handle_service_(context),
+    nt_flush_buffers_file_ex_(0)
+{
+  if (FARPROC nt_flush_buffers_file_ex_ptr = ::GetProcAddress(
+        ::GetModuleHandleA("NTDLL"), "NtFlushBuffersFileEx"))
+  {
+    nt_flush_buffers_file_ex_ = reinterpret_cast<nt_flush_buffers_file_ex_fn>(
+        reinterpret_cast<void*>(nt_flush_buffers_file_ex_ptr));
+  }
+}
+
+void win_iocp_file_service::shutdown()
+{
+  handle_service_.shutdown();
+}
+
+boost::system::error_code win_iocp_file_service::open(
+    win_iocp_file_service::implementation_type& impl,
+    const char* path, file_base::flags open_flags,
+    boost::system::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    ec = boost::asio::error::already_open;
+    return ec;
+  }
+
+  DWORD access = 0;
+  if ((open_flags & file_base::read_only) != 0)
+    access = GENERIC_READ;
+  else if ((open_flags & file_base::write_only) != 0)
+    access = GENERIC_WRITE;
+  else if ((open_flags & file_base::read_write) != 0)
+    access = GENERIC_READ | GENERIC_WRITE;
+
+  DWORD disposition = 0;
+  if ((open_flags & file_base::create) != 0)
+  {
+    if ((open_flags & file_base::exclusive) != 0)
+      disposition = CREATE_NEW;
+    else
+      disposition = OPEN_ALWAYS;
+  }
+  else
+  {
+    if ((open_flags & file_base::truncate) != 0)
+      disposition = TRUNCATE_EXISTING;
+    else
+      disposition = OPEN_EXISTING;
+  }
+
+  DWORD flags = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED;
+  if (impl.is_stream_)
+    flags |= FILE_FLAG_SEQUENTIAL_SCAN;
+  else
+    flags |= FILE_FLAG_RANDOM_ACCESS;
+  if ((open_flags & file_base::sync_all_on_write) != 0)
+    flags |= FILE_FLAG_WRITE_THROUGH;
+
+  HANDLE handle = ::CreateFileA(path, access, 0, 0, disposition, flags, 0);
+  if (handle != INVALID_HANDLE_VALUE)
+  {
+    if (disposition == OPEN_ALWAYS && (open_flags & file_base::truncate) != 0)
+    {
+      if (!::SetEndOfFile(handle))
+      {
+        DWORD last_error = ::GetLastError();
+        ::CloseHandle(handle);
+        ec.assign(last_error, boost::asio::error::get_system_category());
+        return ec;
+      }
+    }
+
+    handle_service_.assign(impl, handle, ec);
+    if (ec)
+      ::CloseHandle(handle);
+    impl.offset_ = 0;
+    return ec;
+  }
+  else
+  {
+    DWORD last_error = ::GetLastError();
+    ec.assign(last_error, boost::asio::error::get_system_category());
+    return ec;
+  }
+}
+
+uint64_t win_iocp_file_service::size(
+    const win_iocp_file_service::implementation_type& impl,
+    boost::system::error_code& ec) const
+{
+  LARGE_INTEGER result;
+  if (::GetFileSizeEx(native_handle(impl), &result))
+  {
+    ec.assign(0, ec.category());
+    return static_cast<uint64_t>(result.QuadPart);
+  }
+  else
+  {
+    DWORD last_error = ::GetLastError();
+    ec.assign(last_error, boost::asio::error::get_system_category());
+    return 0;
+  }
+}
+
+boost::system::error_code win_iocp_file_service::resize(
+    win_iocp_file_service::implementation_type& impl,
+    uint64_t n, boost::system::error_code& ec)
+{
+  LARGE_INTEGER distance;
+  distance.QuadPart = n;
+  if (::SetFilePointerEx(native_handle(impl), distance, 0, FILE_BEGIN))
+  {
+    BOOL result = ::SetEndOfFile(native_handle(impl));
+    DWORD last_error = ::GetLastError();
+
+    distance.QuadPart = static_cast<LONGLONG>(impl.offset_);
+    if (!::SetFilePointerEx(native_handle(impl), distance, 0, FILE_BEGIN))
+    {
+      result = FALSE;
+      last_error = ::GetLastError();
+    }
+
+    if (result)
+      ec.assign(0, ec.category());
+    else
+      ec.assign(last_error, boost::asio::error::get_system_category());
+    return ec;
+  }
+  else
+  {
+    DWORD last_error = ::GetLastError();
+    ec.assign(last_error, boost::asio::error::get_system_category());
+    return ec;
+  }
+}
+
+boost::system::error_code win_iocp_file_service::sync_all(
+    win_iocp_file_service::implementation_type& impl,
+    boost::system::error_code& ec)
+{
+  BOOL result = ::FlushFileBuffers(native_handle(impl));
+  if (result)
+  {
+    ec.assign(0, ec.category());
+    return ec;
+  }
+  else
+  {
+    DWORD last_error = ::GetLastError();
+    ec.assign(last_error, boost::asio::error::get_system_category());
+    return ec;
+  }
+}
+
+boost::system::error_code win_iocp_file_service::sync_data(
+    win_iocp_file_service::implementation_type& impl,
+    boost::system::error_code& ec)
+{
+  if (nt_flush_buffers_file_ex_)
+  {
+    io_status_block status = {};
+    if (!nt_flush_buffers_file_ex_(native_handle(impl),
+          flush_flags_file_data_sync_only, 0, 0, &status))
+    {
+      ec.assign(0, ec.category());
+      return ec;
+    }
+  }
+  return sync_all(impl, ec);
+}
+
+uint64_t win_iocp_file_service::seek(
+    win_iocp_file_service::implementation_type& impl, int64_t offset,
+    file_base::seek_basis whence, boost::system::error_code& ec)
+{
+  DWORD method;
+  switch (whence)
+  {
+  case file_base::seek_set:
+    method = FILE_BEGIN;
+    break;
+  case file_base::seek_cur:
+    method = FILE_CURRENT;
+    break;
+  case file_base::seek_end:
+    method = FILE_END;
+    break;
+  default:
+    ec = boost::asio::error::invalid_argument;
+    return 0;
+  }
+
+  LARGE_INTEGER distance, new_offset;
+  distance.QuadPart = offset;
+  if (::SetFilePointerEx(native_handle(impl), distance, &new_offset, method))
+  {
+    impl.offset_ = new_offset.QuadPart;
+    ec.assign(0, ec.category());
+    return impl.offset_;
+  }
+  else
+  {
+    DWORD last_error = ::GetLastError();
+    ec.assign(last_error, boost::asio::error::get_system_category());
+    return 0;
+  }
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+       //   && defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_FILE_SERVICE_IPP
diff --git a/boost/asio/detail/impl/win_iocp_handle_service.ipp b/boost/asio/detail/impl/win_iocp_handle_service.ipp
index 4d65ed9ad39121c3b58e8cacb6bccc8c76b1d2b5..491f6caf0cf4545c19a4ca8576c4ab1d640e5586 100644
--- a/boost/asio/detail/impl/win_iocp_handle_service.ipp
+++ b/boost/asio/detail/impl/win_iocp_handle_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_iocp_handle_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -225,6 +225,38 @@ boost::system::error_code win_iocp_handle_service::close(
   return ec;
 }
 
+win_iocp_handle_service::native_handle_type win_iocp_handle_service::release(
+    win_iocp_handle_service::implementation_type& impl,
+    boost::system::error_code& ec)
+{
+  if (!is_open(impl))
+    return INVALID_HANDLE_VALUE;
+
+  cancel(impl, ec);
+  if (ec)
+    return INVALID_HANDLE_VALUE;
+
+  nt_set_info_fn fn = get_nt_set_info();
+  if (fn == 0)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return INVALID_HANDLE_VALUE;
+  }
+
+  ULONG_PTR iosb[2] = { 0, 0 };
+  void* info[2] = { 0, 0 };
+  if (fn(impl.handle_, iosb, &info, sizeof(info),
+        61 /* FileReplaceCompletionInformation */))
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return INVALID_HANDLE_VALUE;
+  }
+
+  native_handle_type tmp = impl.handle_;
+  impl.handle_ = INVALID_HANDLE_VALUE;
+  return tmp;
+}
+
 boost::system::error_code win_iocp_handle_service::cancel(
     win_iocp_handle_service::implementation_type& impl,
     boost::system::error_code& ec)
@@ -516,6 +548,47 @@ void win_iocp_handle_service::close_for_destruction(implementation_type& impl)
   }
 }
 
+win_iocp_handle_service::nt_set_info_fn
+win_iocp_handle_service::get_nt_set_info()
+{
+  void* ptr = interlocked_compare_exchange_pointer(&nt_set_info_, 0, 0);
+  if (!ptr)
+  {
+    if (HMODULE h = ::GetModuleHandleA("NTDLL.DLL"))
+      ptr = reinterpret_cast<void*>(GetProcAddress(h, "NtSetInformationFile"));
+
+    // On failure, set nt_set_info_ to a special value to indicate that the
+    // NtSetInformationFile function is unavailable. That way we won't bother
+    // trying to look it up again.
+    interlocked_exchange_pointer(&nt_set_info_, ptr ? ptr : this);
+  }
+
+  return reinterpret_cast<nt_set_info_fn>(ptr == this ? 0 : ptr);
+}
+
+void* win_iocp_handle_service::interlocked_compare_exchange_pointer(
+    void** dest, void* exch, void* cmp)
+{
+#if defined(_M_IX86)
+  return reinterpret_cast<void*>(InterlockedCompareExchange(
+        reinterpret_cast<PLONG>(dest), reinterpret_cast<LONG>(exch),
+        reinterpret_cast<LONG>(cmp)));
+#else
+  return InterlockedCompareExchangePointer(dest, exch, cmp);
+#endif
+}
+
+void* win_iocp_handle_service::interlocked_exchange_pointer(
+    void** dest, void* val)
+{
+#if defined(_M_IX86)
+  return reinterpret_cast<void*>(InterlockedExchange(
+        reinterpret_cast<PLONG>(dest), reinterpret_cast<LONG>(val)));
+#else
+  return InterlockedExchangePointer(dest, val);
+#endif
+}
+
 } // namespace detail
 } // namespace asio
 } // namespace boost
diff --git a/boost/asio/detail/impl/win_iocp_io_context.hpp b/boost/asio/detail/impl/win_iocp_io_context.hpp
index 44e9ac4cd7df14e12131991943db20553dea77d1..932a3b31030e693f73dbec8b04e7b6d2b6ac74ec 100644
--- a/boost/asio/detail/impl/win_iocp_io_context.hpp
+++ b/boost/asio/detail/impl/win_iocp_io_context.hpp
@@ -2,7 +2,7 @@
 // detail/impl/win_iocp_io_context.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -82,6 +82,22 @@ std::size_t win_iocp_io_context::cancel_timer(timer_queue<Time_Traits>& queue,
   return n;
 }
 
+template <typename Time_Traits>
+void win_iocp_io_context::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data* timer,
+    void* cancellation_key)
+{
+  // If the service has been shut down we silently ignore the cancellation.
+  if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
+    return;
+
+  mutex::scoped_lock lock(dispatch_mutex_);
+  op_queue<win_iocp_operation> ops;
+  queue.cancel_timer_by_key(timer, ops, cancellation_key);
+  lock.unlock();
+  post_deferred_completions(ops);
+}
+
 template <typename Time_Traits>
 void win_iocp_io_context::move_timer(timer_queue<Time_Traits>& queue,
     typename timer_queue<Time_Traits>::per_timer_data& to,
diff --git a/boost/asio/detail/impl/win_iocp_io_context.ipp b/boost/asio/detail/impl/win_iocp_io_context.ipp
index 4abce6c4cb3ec365dae89aef34eff0d4dc3717bc..1b4f9187ab9617dbc3d47e83910b260e21a5ee2c 100644
--- a/boost/asio/detail/impl/win_iocp_io_context.ipp
+++ b/boost/asio/detail/impl/win_iocp_io_context.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_iocp_io_context.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/win_iocp_serial_port_service.ipp b/boost/asio/detail/impl/win_iocp_serial_port_service.ipp
index 269abea8ee55fb59c41761393918647350ed4829..50b55e1d1cf9c1af4716f64eff83ced114fc8b53 100644
--- a/boost/asio/detail/impl/win_iocp_serial_port_service.ipp
+++ b/boost/asio/detail/impl/win_iocp_serial_port_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_iocp_serial_port_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/detail/impl/win_iocp_socket_service_base.ipp b/boost/asio/detail/impl/win_iocp_socket_service_base.ipp
index c4c0dff1dd6d13745cce574adf949a05af55ab0a..668e73c4004f7e3c95715e49e9d638af857355e3 100644
--- a/boost/asio/detail/impl/win_iocp_socket_service_base.ipp
+++ b/boost/asio/detail/impl/win_iocp_socket_service_base.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_iocp_socket_service_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -467,23 +467,24 @@ void win_iocp_socket_service_base::start_receive_op(
   }
 }
 
-void win_iocp_socket_service_base::start_null_buffers_receive_op(
+int win_iocp_socket_service_base::start_null_buffers_receive_op(
     win_iocp_socket_service_base::base_implementation_type& impl,
-    socket_base::message_flags flags, reactor_op* op)
+    socket_base::message_flags flags, reactor_op* op, operation* iocp_op)
 {
   if ((impl.state_ & socket_ops::stream_oriented) != 0)
   {
     // For stream sockets on Windows, we may issue a 0-byte overlapped
     // WSARecv to wait until there is data available on the socket.
     ::WSABUF buf = { 0, 0 };
-    start_receive_op(impl, &buf, 1, flags, false, op);
+    start_receive_op(impl, &buf, 1, flags, false, iocp_op);
+    return -1;
   }
   else
   {
-    start_reactor_op(impl,
-        (flags & socket_base::message_out_of_band)
-          ? select_reactor::except_op : select_reactor::read_op,
-        op);
+    int op_type = (flags & socket_base::message_out_of_band)
+      ? select_reactor::except_op : select_reactor::read_op;
+    start_reactor_op(impl, op_type, op);
+    return op_type;
   }
 }
 
@@ -548,11 +549,17 @@ void win_iocp_socket_service_base::start_accept_op(
 
 void win_iocp_socket_service_base::restart_accept_op(
     socket_type s, socket_holder& new_socket, int family, int type,
-    int protocol, void* output_buffer, DWORD address_length, operation* op)
+    int protocol, void* output_buffer, DWORD address_length,
+    long* cancel_requested, operation* op)
 {
   new_socket.reset();
   iocp_service_.work_started();
 
+  // Check if we were cancelled after the first AcceptEx completed.
+  if (cancel_requested)
+    if (::InterlockedExchangeAdd(cancel_requested, 0) == 1)
+      iocp_service_.on_completion(op, boost::asio::error::operation_aborted);
+
   boost::system::error_code ec;
   new_socket.reset(socket_ops::socket(family, type, protocol, ec));
   if (new_socket.get() == invalid_socket)
@@ -566,7 +573,19 @@ void win_iocp_socket_service_base::restart_accept_op(
     if (!result && last_error != WSA_IO_PENDING)
       iocp_service_.on_completion(op, last_error);
     else
+    {
+#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
+      if (cancel_requested)
+      {
+        if (::InterlockedExchangeAdd(cancel_requested, 0) == 1)
+        {
+          HANDLE sock_as_handle = reinterpret_cast<HANDLE>(s);
+          ::CancelIoEx(sock_as_handle, op);
+        }
+      }
+#endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
       iocp_service_.on_pending(op);
+    }
   }
 }
 
@@ -588,10 +607,10 @@ void win_iocp_socket_service_base::start_reactor_op(
   iocp_service_.post_immediate_completion(op, false);
 }
 
-void win_iocp_socket_service_base::start_connect_op(
+int win_iocp_socket_service_base::start_connect_op(
     win_iocp_socket_service_base::base_implementation_type& impl,
-    int family, int type, const socket_addr_type* addr,
-    std::size_t addrlen, win_iocp_socket_connect_op_base* op)
+    int family, int type, const socket_addr_type* addr, std::size_t addrlen,
+    win_iocp_socket_connect_op_base* op, operation* iocp_op)
 {
   // If ConnectEx is available, use that.
   if (family == BOOST_ASIO_OS_DEF(AF_INET)
@@ -616,7 +635,7 @@ void win_iocp_socket_service_base::start_connect_op(
       if (op->ec_ && op->ec_ != boost::asio::error::invalid_argument)
       {
         iocp_service_.post_immediate_completion(op, false);
-        return;
+        return -1;
       }
 
       op->connect_ex_ = true;
@@ -624,13 +643,13 @@ void win_iocp_socket_service_base::start_connect_op(
       iocp_service_.work_started();
 
       BOOL result = connect_ex(impl.socket_,
-          addr, static_cast<int>(addrlen), 0, 0, 0, op);
+          addr, static_cast<int>(addrlen), 0, 0, 0, iocp_op);
       DWORD last_error = ::WSAGetLastError();
       if (!result && last_error != WSA_IO_PENDING)
-        iocp_service_.on_completion(op, last_error);
+        iocp_service_.on_completion(iocp_op, last_error);
       else
-        iocp_service_.on_pending(op);
-      return;
+        iocp_service_.on_pending(iocp_op);
+      return -1;
     }
   }
 
@@ -650,12 +669,13 @@ void win_iocp_socket_service_base::start_connect_op(
         op->ec_ = boost::system::error_code();
         r.start_op(select_reactor::connect_op, impl.socket_,
             impl.reactor_data_, op, false, false);
-        return;
+        return select_reactor::connect_op;
       }
     }
   }
 
   r.post_immediate_completion(op, false);
+  return -1;
 }
 
 void win_iocp_socket_service_base::close_for_destruction(
diff --git a/boost/asio/detail/impl/win_mutex.ipp b/boost/asio/detail/impl/win_mutex.ipp
index 72ddef8a84a2868ad66c517d6e4f9b2d0b430087..f08bc8500ff0a1a63c829cdf780b88ecba73ae40 100644
--- a/boost/asio/detail/impl/win_mutex.ipp
+++ b/boost/asio/detail/impl/win_mutex.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_mutex.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/win_object_handle_service.ipp b/boost/asio/detail/impl/win_object_handle_service.ipp
index b4e066c8ee1251bf5f4bdcc82c3ff5991f1a1251..54b08750cee5370b388760b781118854ed1f2c1a 100644
--- a/boost/asio/detail/impl/win_object_handle_service.ipp
+++ b/boost/asio/detail/impl/win_object_handle_service.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_object_handle_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/detail/impl/win_static_mutex.ipp b/boost/asio/detail/impl/win_static_mutex.ipp
index 88a54b99beda798c80a17c63789a949ce4cc0815..6cad7f4ad30168728172f7421d743812dcb81e6c 100644
--- a/boost/asio/detail/impl/win_static_mutex.ipp
+++ b/boost/asio/detail/impl/win_static_mutex.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_static_mutex.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/win_thread.ipp b/boost/asio/detail/impl/win_thread.ipp
index b901e49afc2bfc4bf0bb4938bc14d86ec93bf687..ee885ee0dfc156cf095d7deb89fa28119ae59c71 100644
--- a/boost/asio/detail/impl/win_thread.ipp
+++ b/boost/asio/detail/impl/win_thread.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_thread.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/win_tss_ptr.ipp b/boost/asio/detail/impl/win_tss_ptr.ipp
index c7a82a15d5d65b715538f11c3365fae2f585d498..545aaf254c40db8b86cdcd76a2d986444a533f83 100644
--- a/boost/asio/detail/impl/win_tss_ptr.ipp
+++ b/boost/asio/detail/impl/win_tss_ptr.ipp
@@ -2,7 +2,7 @@
 // detail/impl/win_tss_ptr.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/winrt_ssocket_service_base.ipp b/boost/asio/detail/impl/winrt_ssocket_service_base.ipp
index cecb16ceb88d27cefdcab30c4387611430a7ee67..dd95f7df2c5b5da6a42cde02da5dbf40b9785a57 100644
--- a/boost/asio/detail/impl/winrt_ssocket_service_base.ipp
+++ b/boost/asio/detail/impl/winrt_ssocket_service_base.ipp
@@ -2,7 +2,7 @@
 // detail/impl/winrt_ssocket_service_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/winrt_timer_scheduler.hpp b/boost/asio/detail/impl/winrt_timer_scheduler.hpp
index 8cc5d3c6ade169a4b0536736ee3b6becb55013f5..c8d42b82bd23bfa942a7211d9bb510bb92000b7c 100644
--- a/boost/asio/detail/impl/winrt_timer_scheduler.hpp
+++ b/boost/asio/detail/impl/winrt_timer_scheduler.hpp
@@ -2,7 +2,7 @@
 // detail/impl/winrt_timer_scheduler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/winrt_timer_scheduler.ipp b/boost/asio/detail/impl/winrt_timer_scheduler.ipp
index a8ee666d154904ef34a6892e6ca2e9d4193529fe..acd3e22c4ecfd2a608879bfb0d6c483a9d32eaa1 100644
--- a/boost/asio/detail/impl/winrt_timer_scheduler.ipp
+++ b/boost/asio/detail/impl/winrt_timer_scheduler.ipp
@@ -2,7 +2,7 @@
 // detail/impl/winrt_timer_scheduler.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/impl/winsock_init.ipp b/boost/asio/detail/impl/winsock_init.ipp
index a7e3ac9e8175c5351cc9a58c8ba38ccc4e560e35..157f1de39312d1742e5b096a5ef8244faa283829 100644
--- a/boost/asio/detail/impl/winsock_init.ipp
+++ b/boost/asio/detail/impl/winsock_init.ipp
@@ -2,7 +2,7 @@
 // detail/impl/winsock_init.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/io_control.hpp b/boost/asio/detail/io_control.hpp
index cbf6d45d19b791b29599e81b6382580ffe37fade..185b2033fbaf0f0f8690aac127c47257c888d9b8 100644
--- a/boost/asio/detail/io_control.hpp
+++ b/boost/asio/detail/io_control.hpp
@@ -2,7 +2,7 @@
 // detail/io_control.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/io_object_impl.hpp b/boost/asio/detail/io_object_impl.hpp
index cb4cc896738c610ec0171153ed9099e3ca111f13..13c133249941c507b0df12fd38c0624b518143ba 100644
--- a/boost/asio/detail/io_object_impl.hpp
+++ b/boost/asio/detail/io_object_impl.hpp
@@ -2,7 +2,7 @@
 // io_object_impl.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/io_uring_descriptor_read_at_op.hpp b/boost/asio/detail/io_uring_descriptor_read_at_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..4c47c7840df3bcd5c0caf3059c14c5c63c17ba4d
--- /dev/null
+++ b/boost/asio/detail/io_uring_descriptor_read_at_op.hpp
@@ -0,0 +1,192 @@
+//
+// detail/io_uring_descriptor_read_at_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_READ_AT_OP_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_READ_AT_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/cstdint.hpp>
+#include <boost/asio/detail/descriptor_ops.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_work.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/memory.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename MutableBufferSequence>
+class io_uring_descriptor_read_at_op_base : public io_uring_operation
+{
+public:
+  io_uring_descriptor_read_at_op_base(
+      const boost::system::error_code& success_ec, int descriptor,
+      descriptor_ops::state_type state, uint64_t offset,
+      const MutableBufferSequence& buffers, func_type complete_func)
+    : io_uring_operation(success_ec,
+        &io_uring_descriptor_read_at_op_base::do_prepare,
+        &io_uring_descriptor_read_at_op_base::do_perform, complete_func),
+      descriptor_(descriptor),
+      state_(state),
+      offset_(offset),
+      buffers_(buffers),
+      bufs_(buffers)
+  {
+  }
+
+  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
+  {
+    io_uring_descriptor_read_at_op_base* o(
+        static_cast<io_uring_descriptor_read_at_op_base*>(base));
+
+    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
+    {
+      ::io_uring_prep_poll_add(sqe, o->descriptor_, POLLIN);
+    }
+    else if (o->bufs_.is_single_buffer && o->bufs_.is_registered_buffer)
+    {
+      ::io_uring_prep_read_fixed(sqe, o->descriptor_,
+          o->bufs_.buffers()->iov_base, o->bufs_.buffers()->iov_len,
+          o->offset_, o->bufs_.registered_id().native_handle());
+    }
+    else
+    {
+      ::io_uring_prep_readv(sqe, o->descriptor_,
+          o->bufs_.buffers(), o->bufs_.count(), o->offset_);
+    }
+  }
+
+  static bool do_perform(io_uring_operation* base, bool after_completion)
+  {
+    io_uring_descriptor_read_at_op_base* o(
+        static_cast<io_uring_descriptor_read_at_op_base*>(base));
+
+    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
+    {
+      if (o->bufs_.is_single_buffer)
+      {
+        return descriptor_ops::non_blocking_read_at1(o->descriptor_,
+            o->offset_, o->bufs_.first(o->buffers_).data(),
+            o->bufs_.first(o->buffers_).size(), o->ec_,
+            o->bytes_transferred_);
+      }
+      else
+      {
+        return descriptor_ops::non_blocking_read_at(o->descriptor_,
+            o->offset_, o->bufs_.buffers(), o->bufs_.count(),
+            o->ec_, o->bytes_transferred_);
+      }
+    }
+    else if (after_completion)
+    {
+      if (!o->ec_ && o->bytes_transferred_ == 0)
+        o->ec_ = boost::asio::error::eof;
+    }
+
+    if (o->ec_ && o->ec_ == boost::asio::error::would_block)
+    {
+      o->state_ |= descriptor_ops::internal_non_blocking;
+      return false;
+    }
+
+    return after_completion;
+  }
+
+private:
+  int descriptor_;
+  descriptor_ops::state_type state_;
+  uint64_t offset_;
+  MutableBufferSequence buffers_;
+  buffer_sequence_adapter<boost::asio::mutable_buffer,
+      MutableBufferSequence> bufs_;
+};
+
+template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
+class io_uring_descriptor_read_at_op
+  : public io_uring_descriptor_read_at_op_base<MutableBufferSequence>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_descriptor_read_at_op);
+
+  io_uring_descriptor_read_at_op(const boost::system::error_code& success_ec,
+      int descriptor, descriptor_ops::state_type state, uint64_t offset,
+      const MutableBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+    : io_uring_descriptor_read_at_op_base<MutableBufferSequence>(
+        success_ec, descriptor, state, offset, buffers,
+        &io_uring_descriptor_read_at_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_descriptor_read_at_op* o
+      (static_cast<io_uring_descriptor_read_at_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, o->ec_, o->bytes_transferred_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_READ_AT_OP_HPP
diff --git a/boost/asio/detail/io_uring_descriptor_read_op.hpp b/boost/asio/detail/io_uring_descriptor_read_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f510b856771d5bfa26d78a38d24feafa75b29358
--- /dev/null
+++ b/boost/asio/detail/io_uring_descriptor_read_op.hpp
@@ -0,0 +1,187 @@
+//
+// detail/io_uring_descriptor_read_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_READ_OP_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_READ_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/descriptor_ops.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_work.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/memory.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename MutableBufferSequence>
+class io_uring_descriptor_read_op_base : public io_uring_operation
+{
+public:
+  io_uring_descriptor_read_op_base(const boost::system::error_code& success_ec,
+      int descriptor, descriptor_ops::state_type state,
+      const MutableBufferSequence& buffers, func_type complete_func)
+    : io_uring_operation(success_ec,
+        &io_uring_descriptor_read_op_base::do_prepare,
+        &io_uring_descriptor_read_op_base::do_perform, complete_func),
+      descriptor_(descriptor),
+      state_(state),
+      buffers_(buffers),
+      bufs_(buffers)
+  {
+  }
+
+  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
+  {
+    io_uring_descriptor_read_op_base* o(
+        static_cast<io_uring_descriptor_read_op_base*>(base));
+
+    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
+    {
+      ::io_uring_prep_poll_add(sqe, o->descriptor_, POLLIN);
+    }
+    else if (o->bufs_.is_single_buffer && o->bufs_.is_registered_buffer)
+    {
+      ::io_uring_prep_read_fixed(sqe, o->descriptor_,
+          o->bufs_.buffers()->iov_base, o->bufs_.buffers()->iov_len,
+          0, o->bufs_.registered_id().native_handle());
+    }
+    else
+    {
+      ::io_uring_prep_readv(sqe, o->descriptor_,
+          o->bufs_.buffers(), o->bufs_.count(), -1);
+    }
+  }
+
+  static bool do_perform(io_uring_operation* base, bool after_completion)
+  {
+    io_uring_descriptor_read_op_base* o(
+        static_cast<io_uring_descriptor_read_op_base*>(base));
+
+    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
+    {
+      if (o->bufs_.is_single_buffer)
+      {
+        return descriptor_ops::non_blocking_read1(
+            o->descriptor_, o->bufs_.first(o->buffers_).data(),
+            o->bufs_.first(o->buffers_).size(), o->ec_,
+            o->bytes_transferred_);
+      }
+      else
+      {
+        return descriptor_ops::non_blocking_read(
+            o->descriptor_, o->bufs_.buffers(), o->bufs_.count(),
+            o->ec_, o->bytes_transferred_);
+      }
+    }
+    else if (after_completion)
+    {
+      if (!o->ec_ && o->bytes_transferred_ == 0)
+        o->ec_ = boost::asio::error::eof;
+    }
+
+    if (o->ec_ && o->ec_ == boost::asio::error::would_block)
+    {
+      o->state_ |= descriptor_ops::internal_non_blocking;
+      return false;
+    }
+
+    return after_completion;
+  }
+
+private:
+  int descriptor_;
+  descriptor_ops::state_type state_;
+  MutableBufferSequence buffers_;
+  buffer_sequence_adapter<boost::asio::mutable_buffer,
+      MutableBufferSequence> bufs_;
+};
+
+template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
+class io_uring_descriptor_read_op
+  : public io_uring_descriptor_read_op_base<MutableBufferSequence>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_descriptor_read_op);
+
+  io_uring_descriptor_read_op(const boost::system::error_code& success_ec,
+      int descriptor, descriptor_ops::state_type state,
+      const MutableBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+    : io_uring_descriptor_read_op_base<MutableBufferSequence>(success_ec,
+        descriptor, state, buffers, &io_uring_descriptor_read_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_descriptor_read_op* o
+      (static_cast<io_uring_descriptor_read_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, o->ec_, o->bytes_transferred_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_READ_OP_HPP
diff --git a/boost/asio/detail/io_uring_descriptor_service.hpp b/boost/asio/detail/io_uring_descriptor_service.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b76c218ee929de1f7d08ebbb0fa9e76e54322773
--- /dev/null
+++ b/boost/asio/detail/io_uring_descriptor_service.hpp
@@ -0,0 +1,663 @@
+//
+// detail/io_uring_descriptor_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/cancellation_type.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/descriptor_ops.hpp>
+#include <boost/asio/detail/io_uring_descriptor_read_at_op.hpp>
+#include <boost/asio/detail/io_uring_descriptor_read_op.hpp>
+#include <boost/asio/detail/io_uring_descriptor_write_at_op.hpp>
+#include <boost/asio/detail/io_uring_descriptor_write_op.hpp>
+#include <boost/asio/detail/io_uring_null_buffers_op.hpp>
+#include <boost/asio/detail/io_uring_service.hpp>
+#include <boost/asio/detail/io_uring_wait_op.hpp>
+#include <boost/asio/detail/memory.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/posix/descriptor_base.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class io_uring_descriptor_service :
+  public execution_context_service_base<io_uring_descriptor_service>
+{
+public:
+  // The native type of a descriptor.
+  typedef int native_handle_type;
+
+  // The implementation type of the descriptor.
+  class implementation_type
+    : private boost::asio::detail::noncopyable
+  {
+  public:
+    // Default constructor.
+    implementation_type()
+      : descriptor_(-1),
+        state_(0)
+    {
+    }
+
+  private:
+    // Only this service will have access to the internal values.
+    friend class io_uring_descriptor_service;
+
+    // The native descriptor representation.
+    int descriptor_;
+
+    // The current state of the descriptor.
+    descriptor_ops::state_type state_;
+
+    // Per I/O object data used by the io_uring_service.
+    io_uring_service::per_io_object_data io_object_data_;
+  };
+
+  // Constructor.
+  BOOST_ASIO_DECL io_uring_descriptor_service(execution_context& context);
+
+  // Destroy all user-defined handler objects owned by the service.
+  BOOST_ASIO_DECL void shutdown();
+
+  // Construct a new descriptor implementation.
+  BOOST_ASIO_DECL void construct(implementation_type& impl);
+
+  // Move-construct a new descriptor implementation.
+  BOOST_ASIO_DECL void move_construct(implementation_type& impl,
+      implementation_type& other_impl) BOOST_ASIO_NOEXCEPT;
+
+  // Move-assign from another descriptor implementation.
+  BOOST_ASIO_DECL void move_assign(implementation_type& impl,
+      io_uring_descriptor_service& other_service,
+      implementation_type& other_impl);
+
+  // Destroy a descriptor implementation.
+  BOOST_ASIO_DECL void destroy(implementation_type& impl);
+
+  // Assign a native descriptor to a descriptor implementation.
+  BOOST_ASIO_DECL boost::system::error_code assign(implementation_type& impl,
+      const native_handle_type& native_descriptor,
+      boost::system::error_code& ec);
+
+  // Determine whether the descriptor is open.
+  bool is_open(const implementation_type& impl) const
+  {
+    return impl.descriptor_ != -1;
+  }
+
+  // Destroy a descriptor implementation.
+  BOOST_ASIO_DECL boost::system::error_code close(implementation_type& impl,
+      boost::system::error_code& ec);
+
+  // Get the native descriptor representation.
+  native_handle_type native_handle(const implementation_type& impl) const
+  {
+    return impl.descriptor_;
+  }
+
+  // Release ownership of the native descriptor representation.
+  BOOST_ASIO_DECL native_handle_type release(implementation_type& impl);
+
+  // Cancel all operations associated with the descriptor.
+  BOOST_ASIO_DECL boost::system::error_code cancel(implementation_type& impl,
+      boost::system::error_code& ec);
+
+  // Perform an IO control command on the descriptor.
+  template <typename IO_Control_Command>
+  boost::system::error_code io_control(implementation_type& impl,
+      IO_Control_Command& command, boost::system::error_code& ec)
+  {
+    descriptor_ops::ioctl(impl.descriptor_, impl.state_,
+        command.name(), static_cast<ioctl_arg_type*>(command.data()), ec);
+    return ec;
+  }
+
+  // Gets the non-blocking mode of the descriptor.
+  bool non_blocking(const implementation_type& impl) const
+  {
+    return (impl.state_ & descriptor_ops::user_set_non_blocking) != 0;
+  }
+
+  // Sets the non-blocking mode of the descriptor.
+  boost::system::error_code non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    descriptor_ops::set_user_non_blocking(
+        impl.descriptor_, impl.state_, mode, ec);
+    return ec;
+  }
+
+  // Gets the non-blocking mode of the native descriptor implementation.
+  bool native_non_blocking(const implementation_type& impl) const
+  {
+    return (impl.state_ & descriptor_ops::internal_non_blocking) != 0;
+  }
+
+  // Sets the non-blocking mode of the native descriptor implementation.
+  boost::system::error_code native_non_blocking(implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    descriptor_ops::set_internal_non_blocking(
+        impl.descriptor_, impl.state_, mode, ec);
+    return ec;
+  }
+
+  // Wait for the descriptor to become ready to read, ready to write, or to have
+  // pending error conditions.
+  boost::system::error_code wait(implementation_type& impl,
+      posix::descriptor_base::wait_type w, boost::system::error_code& ec)
+  {
+    switch (w)
+    {
+    case posix::descriptor_base::wait_read:
+      descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec);
+      break;
+    case posix::descriptor_base::wait_write:
+      descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec);
+      break;
+    case posix::descriptor_base::wait_error:
+      descriptor_ops::poll_error(impl.descriptor_, impl.state_, ec);
+      break;
+    default:
+      ec = boost::asio::error::invalid_argument;
+      break;
+    }
+
+    return ec;
+  }
+
+  // Asynchronously wait for the descriptor to become ready to read, ready to
+  // write, or to have pending error conditions.
+  template <typename Handler, typename IoExecutor>
+  void async_wait(implementation_type& impl,
+      posix::descriptor_base::wait_type w,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    int op_type;
+    int poll_flags;
+    switch (w)
+    {
+    case posix::descriptor_base::wait_read:
+      op_type = io_uring_service::read_op;
+      poll_flags = POLLIN;
+      break;
+    case posix::descriptor_base::wait_write:
+      op_type = io_uring_service::write_op;
+      poll_flags = POLLOUT;
+      break;
+    case posix::descriptor_base::wait_error:
+      op_type = io_uring_service::except_op;
+      poll_flags = POLLPRI | POLLERR | POLLHUP;
+      break;
+    default:
+      op_type = -1;
+      poll_flags = -1;
+      return;
+    }
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_wait_op<Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.descriptor_,
+        poll_flags, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected() && op_type != -1)
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(
+            &io_uring_service_, &impl.io_object_data_, op_type);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "descriptor", &impl, impl.descriptor_, "async_wait"));
+
+    start_op(impl, op_type, p.p, is_continuation, op_type == -1);
+    p.v = p.p = 0;
+  }
+
+  // Write some data to the descriptor.
+  template <typename ConstBufferSequence>
+  size_t write_some(implementation_type& impl,
+      const ConstBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    typedef buffer_sequence_adapter<boost::asio::const_buffer,
+        ConstBufferSequence> bufs_type;
+
+    if (bufs_type::is_single_buffer)
+    {
+      return descriptor_ops::sync_write1(impl.descriptor_,
+          impl.state_, bufs_type::first(buffers).data(),
+          bufs_type::first(buffers).size(), ec);
+    }
+    else
+    {
+      bufs_type bufs(buffers);
+
+      return descriptor_ops::sync_write(impl.descriptor_, impl.state_,
+          bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
+    }
+  }
+
+  // Wait until data can be written without blocking.
+  size_t write_some(implementation_type& impl,
+      const null_buffers&, boost::system::error_code& ec)
+  {
+    // Wait for descriptor to become ready.
+    descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec);
+
+    return 0;
+  }
+
+  // Start an asynchronous write. The data being sent must be valid for the
+  // lifetime of the asynchronous operation.
+  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
+  void async_write_some(implementation_type& impl,
+      const ConstBufferSequence& buffers, Handler& handler,
+      const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_descriptor_write_op<
+      ConstBufferSequence, Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.descriptor_,
+        impl.state_, buffers, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
+            &impl.io_object_data_, io_uring_service::write_op);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "descriptor", &impl, impl.descriptor_, "async_write_some"));
+
+    start_op(impl, io_uring_service::write_op, p.p, is_continuation,
+        buffer_sequence_adapter<boost::asio::const_buffer,
+          ConstBufferSequence>::all_empty(buffers));
+    p.v = p.p = 0;
+  }
+
+  // Start an asynchronous wait until data can be written without blocking.
+  template <typename Handler, typename IoExecutor>
+  void async_write_some(implementation_type& impl,
+      const null_buffers&, Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.descriptor_, POLLOUT, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
+            &impl.io_object_data_, io_uring_service::write_op);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(),
+          *p.p, "descriptor", &impl, impl.descriptor_,
+          "async_write_some(null_buffers)"));
+
+    start_op(impl, io_uring_service::write_op, p.p, is_continuation, false);
+    p.v = p.p = 0;
+  }
+
+  // Write some data to the descriptor at the specified offset.
+  template <typename ConstBufferSequence>
+  size_t write_some_at(implementation_type& impl, uint64_t offset,
+      const ConstBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    typedef buffer_sequence_adapter<boost::asio::const_buffer,
+        ConstBufferSequence> bufs_type;
+
+    if (bufs_type::is_single_buffer)
+    {
+      return descriptor_ops::sync_write_at1(impl.descriptor_,
+          impl.state_, offset, bufs_type::first(buffers).data(),
+          bufs_type::first(buffers).size(), ec);
+    }
+    else
+    {
+      bufs_type bufs(buffers);
+
+      return descriptor_ops::sync_write_at(impl.descriptor_, impl.state_,
+          offset, bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
+    }
+  }
+
+  // Wait until data can be written without blocking.
+  size_t write_some_at(implementation_type& impl, uint64_t,
+      const null_buffers& buffers, boost::system::error_code& ec)
+  {
+    return write_some(impl, buffers, ec);
+  }
+
+  // Start an asynchronous write at the specified offset. The data being sent
+  // must be valid for the lifetime of the asynchronous operation.
+  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
+  void async_write_some_at(implementation_type& impl, uint64_t offset,
+      const ConstBufferSequence& buffers, Handler& handler,
+      const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_descriptor_write_at_op<
+      ConstBufferSequence, Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.descriptor_,
+        impl.state_, offset, buffers, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
+            &impl.io_object_data_, io_uring_service::write_op);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "descriptor", &impl, impl.descriptor_, "async_write_some"));
+
+    start_op(impl, io_uring_service::write_op, p.p, is_continuation,
+        buffer_sequence_adapter<boost::asio::const_buffer,
+          ConstBufferSequence>::all_empty(buffers));
+    p.v = p.p = 0;
+  }
+
+  // Start an asynchronous wait until data can be written without blocking.
+  template <typename Handler, typename IoExecutor>
+  void async_write_some_at(implementation_type& impl,
+      const null_buffers& buffers, Handler& handler, const IoExecutor& io_ex)
+  {
+    return async_write_some(impl, buffers, handler, io_ex);
+  }
+
+  // Read some data from the stream. Returns the number of bytes read.
+  template <typename MutableBufferSequence>
+  size_t read_some(implementation_type& impl,
+      const MutableBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    typedef buffer_sequence_adapter<boost::asio::mutable_buffer,
+        MutableBufferSequence> bufs_type;
+
+    if (bufs_type::is_single_buffer)
+    {
+      return descriptor_ops::sync_read1(impl.descriptor_,
+          impl.state_, bufs_type::first(buffers).data(),
+          bufs_type::first(buffers).size(), ec);
+    }
+    else
+    {
+      bufs_type bufs(buffers);
+
+      return descriptor_ops::sync_read(impl.descriptor_, impl.state_,
+          bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
+    }
+  }
+
+  // Wait until data can be read without blocking.
+  size_t read_some(implementation_type& impl,
+      const null_buffers&, boost::system::error_code& ec)
+  {
+    // Wait for descriptor to become ready.
+    descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec);
+
+    return 0;
+  }
+
+  // Start an asynchronous read. The buffer for the data being read must be
+  // valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence,
+      typename Handler, typename IoExecutor>
+  void async_read_some(implementation_type& impl,
+      const MutableBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_descriptor_read_op<
+      MutableBufferSequence, Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.descriptor_,
+        impl.state_, buffers, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
+            &impl.io_object_data_, io_uring_service::read_op);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "descriptor", &impl, impl.descriptor_, "async_read_some"));
+
+    start_op(impl, io_uring_service::read_op, p.p, is_continuation,
+        buffer_sequence_adapter<boost::asio::mutable_buffer,
+          MutableBufferSequence>::all_empty(buffers));
+    p.v = p.p = 0;
+  }
+
+  // Wait until data can be read without blocking.
+  template <typename Handler, typename IoExecutor>
+  void async_read_some(implementation_type& impl,
+      const null_buffers&, Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.descriptor_, POLLIN, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
+            &impl.io_object_data_, io_uring_service::read_op);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(),
+          *p.p, "descriptor", &impl, impl.descriptor_,
+          "async_read_some(null_buffers)"));
+
+    start_op(impl, io_uring_service::read_op, p.p, is_continuation, false);
+    p.v = p.p = 0;
+  }
+
+  // Read some data at the specified offset. Returns the number of bytes read.
+  template <typename MutableBufferSequence>
+  size_t read_some_at(implementation_type& impl, uint64_t offset,
+      const MutableBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    typedef buffer_sequence_adapter<boost::asio::mutable_buffer,
+        MutableBufferSequence> bufs_type;
+
+    if (bufs_type::is_single_buffer)
+    {
+      return descriptor_ops::sync_read_at1(impl.descriptor_,
+          impl.state_, offset, bufs_type::first(buffers).data(),
+          bufs_type::first(buffers).size(), ec);
+    }
+    else
+    {
+      bufs_type bufs(buffers);
+
+      return descriptor_ops::sync_read_at(impl.descriptor_, impl.state_,
+          offset, bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
+    }
+  }
+
+  // Wait until data can be read without blocking.
+  size_t read_some_at(implementation_type& impl, uint64_t,
+      const null_buffers& buffers, boost::system::error_code& ec)
+  {
+    return read_some(impl, buffers, ec);
+  }
+
+  // Start an asynchronous read. The buffer for the data being read must be
+  // valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence,
+      typename Handler, typename IoExecutor>
+  void async_read_some_at(implementation_type& impl,
+      uint64_t offset, const MutableBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_descriptor_read_at_op<
+      MutableBufferSequence, Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.descriptor_,
+        impl.state_, offset, buffers, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
+            &impl.io_object_data_, io_uring_service::read_op);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "descriptor", &impl, impl.descriptor_, "async_read_some"));
+
+    start_op(impl, io_uring_service::read_op, p.p, is_continuation,
+        buffer_sequence_adapter<boost::asio::mutable_buffer,
+          MutableBufferSequence>::all_empty(buffers));
+    p.v = p.p = 0;
+  }
+
+  // Wait until data can be read without blocking.
+  template <typename Handler, typename IoExecutor>
+  void async_read_some_at(implementation_type& impl, uint64_t,
+      const null_buffers& buffers, Handler& handler, const IoExecutor& io_ex)
+  {
+    return async_read_some(impl, buffers, handler, io_ex);
+  }
+
+private:
+  // Start the asynchronous operation.
+  BOOST_ASIO_DECL void start_op(implementation_type& impl, int op_type,
+      io_uring_operation* op, bool is_continuation, bool noop);
+
+  // Helper class used to implement per-operation cancellation
+  class io_uring_op_cancellation
+  {
+  public:
+    io_uring_op_cancellation(io_uring_service* s,
+        io_uring_service::per_io_object_data* p, int o)
+      : io_uring_service_(s),
+        io_object_data_(p),
+        op_type_(o)
+    {
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+      if (!!(type &
+            (cancellation_type::terminal
+              | cancellation_type::partial
+              | cancellation_type::total)))
+      {
+        io_uring_service_->cancel_ops_by_key(*io_object_data_, op_type_, this);
+      }
+    }
+
+  private:
+    io_uring_service* io_uring_service_;
+    io_uring_service::per_io_object_data* io_object_data_;
+    int op_type_;
+  };
+
+  // The io_uring_service that performs event demultiplexing for the service.
+  io_uring_service& io_uring_service_;
+
+  // Cached success value to avoid accessing category singleton.
+  const boost::system::error_code success_ec_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/detail/impl/io_uring_descriptor_service.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_SERVICE_HPP
diff --git a/boost/asio/detail/io_uring_descriptor_write_at_op.hpp b/boost/asio/detail/io_uring_descriptor_write_at_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..48698ea27d17481080f7930dcc002a381e0c3a3c
--- /dev/null
+++ b/boost/asio/detail/io_uring_descriptor_write_at_op.hpp
@@ -0,0 +1,186 @@
+//
+// detail/io_uring_descriptor_write_at_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_WRITE_AT_OP_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_WRITE_AT_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/descriptor_ops.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_work.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/memory.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename ConstBufferSequence>
+class io_uring_descriptor_write_at_op_base : public io_uring_operation
+{
+public:
+  io_uring_descriptor_write_at_op_base(
+      const boost::system::error_code& success_ec, int descriptor,
+      descriptor_ops::state_type state, uint64_t offset,
+      const ConstBufferSequence& buffers, func_type complete_func)
+    : io_uring_operation(success_ec,
+        &io_uring_descriptor_write_at_op_base::do_prepare,
+        &io_uring_descriptor_write_at_op_base::do_perform, complete_func),
+      descriptor_(descriptor),
+      state_(state),
+      offset_(offset),
+      buffers_(buffers),
+      bufs_(buffers)
+  {
+  }
+
+  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
+  {
+    io_uring_descriptor_write_at_op_base* o(
+        static_cast<io_uring_descriptor_write_at_op_base*>(base));
+
+    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
+    {
+      ::io_uring_prep_poll_add(sqe, o->descriptor_, POLLOUT);
+    }
+    else if (o->bufs_.is_single_buffer && o->bufs_.is_registered_buffer)
+    {
+      ::io_uring_prep_write_fixed(sqe, o->descriptor_,
+          o->bufs_.buffers()->iov_base, o->bufs_.buffers()->iov_len,
+          o->offset_, o->bufs_.registered_id().native_handle());
+    }
+    else
+    {
+      ::io_uring_prep_writev(sqe, o->descriptor_,
+          o->bufs_.buffers(), o->bufs_.count(), o->offset_);
+    }
+  }
+
+  static bool do_perform(io_uring_operation* base, bool after_completion)
+  {
+    io_uring_descriptor_write_at_op_base* o(
+        static_cast<io_uring_descriptor_write_at_op_base*>(base));
+
+    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
+    {
+      if (o->bufs_.is_single_buffer)
+      {
+        return descriptor_ops::non_blocking_write_at1(o->descriptor_,
+            o->offset_, o->bufs_.first(o->buffers_).data(),
+            o->bufs_.first(o->buffers_).size(), o->ec_,
+            o->bytes_transferred_);
+      }
+      else
+      {
+        return descriptor_ops::non_blocking_write_at(o->descriptor_,
+            o->offset_, o->bufs_.buffers(), o->bufs_.count(),
+            o->ec_, o->bytes_transferred_);
+      }
+    }
+
+    if (o->ec_ && o->ec_ == boost::asio::error::would_block)
+    {
+      o->state_ |= descriptor_ops::internal_non_blocking;
+      return false;
+    }
+
+    return after_completion;
+  }
+
+private:
+  int descriptor_;
+  descriptor_ops::state_type state_;
+  uint64_t offset_;
+  ConstBufferSequence buffers_;
+  buffer_sequence_adapter<boost::asio::const_buffer,
+      ConstBufferSequence> bufs_;
+};
+
+template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
+class io_uring_descriptor_write_at_op
+  : public io_uring_descriptor_write_at_op_base<ConstBufferSequence>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_descriptor_write_at_op);
+
+  io_uring_descriptor_write_at_op(const boost::system::error_code& success_ec,
+      int descriptor, descriptor_ops::state_type state, uint64_t offset,
+      const ConstBufferSequence& buffers, Handler& handler,
+      const IoExecutor& io_ex)
+    : io_uring_descriptor_write_at_op_base<ConstBufferSequence>(
+        success_ec, descriptor, state, offset, buffers,
+        &io_uring_descriptor_write_at_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_descriptor_write_at_op* o
+      (static_cast<io_uring_descriptor_write_at_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, o->ec_, o->bytes_transferred_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_WRITE_AT_OP_HPP
diff --git a/boost/asio/detail/io_uring_descriptor_write_op.hpp b/boost/asio/detail/io_uring_descriptor_write_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c88aa2cc06b8a961c135b89f5ae39dfd20003a9f
--- /dev/null
+++ b/boost/asio/detail/io_uring_descriptor_write_op.hpp
@@ -0,0 +1,182 @@
+//
+// detail/io_uring_descriptor_write_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_WRITE_OP_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_WRITE_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/descriptor_ops.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_work.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/memory.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename ConstBufferSequence>
+class io_uring_descriptor_write_op_base : public io_uring_operation
+{
+public:
+  io_uring_descriptor_write_op_base(const boost::system::error_code& success_ec,
+      int descriptor, descriptor_ops::state_type state,
+      const ConstBufferSequence& buffers, func_type complete_func)
+    : io_uring_operation(success_ec,
+        &io_uring_descriptor_write_op_base::do_prepare,
+        &io_uring_descriptor_write_op_base::do_perform, complete_func),
+      descriptor_(descriptor),
+      state_(state),
+      buffers_(buffers),
+      bufs_(buffers)
+  {
+  }
+
+  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
+  {
+    io_uring_descriptor_write_op_base* o(
+        static_cast<io_uring_descriptor_write_op_base*>(base));
+
+    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
+    {
+      ::io_uring_prep_poll_add(sqe, o->descriptor_, POLLOUT);
+    }
+    else if (o->bufs_.is_single_buffer && o->bufs_.is_registered_buffer)
+    {
+      ::io_uring_prep_write_fixed(sqe, o->descriptor_,
+          o->bufs_.buffers()->iov_base, o->bufs_.buffers()->iov_len,
+          0, o->bufs_.registered_id().native_handle());
+    }
+    else
+    {
+      ::io_uring_prep_writev(sqe, o->descriptor_,
+          o->bufs_.buffers(), o->bufs_.count(), -1);
+    }
+  }
+
+  static bool do_perform(io_uring_operation* base, bool after_completion)
+  {
+    io_uring_descriptor_write_op_base* o(
+        static_cast<io_uring_descriptor_write_op_base*>(base));
+
+    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
+    {
+      if (o->bufs_.is_single_buffer)
+      {
+        return descriptor_ops::non_blocking_write1(
+            o->descriptor_, o->bufs_.first(o->buffers_).data(),
+            o->bufs_.first(o->buffers_).size(), o->ec_,
+            o->bytes_transferred_);
+      }
+      else
+      {
+        return descriptor_ops::non_blocking_write(
+            o->descriptor_, o->bufs_.buffers(), o->bufs_.count(),
+            o->ec_, o->bytes_transferred_);
+      }
+    }
+
+    if (o->ec_ && o->ec_ == boost::asio::error::would_block)
+    {
+      o->state_ |= descriptor_ops::internal_non_blocking;
+      return false;
+    }
+
+    return after_completion;
+  }
+
+private:
+  int descriptor_;
+  descriptor_ops::state_type state_;
+  ConstBufferSequence buffers_;
+  buffer_sequence_adapter<boost::asio::const_buffer,
+      ConstBufferSequence> bufs_;
+};
+
+template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
+class io_uring_descriptor_write_op
+  : public io_uring_descriptor_write_op_base<ConstBufferSequence>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_descriptor_write_op);
+
+  io_uring_descriptor_write_op(const boost::system::error_code& success_ec,
+      int descriptor, descriptor_ops::state_type state,
+      const ConstBufferSequence& buffers, Handler& handler,
+      const IoExecutor& io_ex)
+    : io_uring_descriptor_write_op_base<ConstBufferSequence>(success_ec,
+        descriptor, state, buffers, &io_uring_descriptor_write_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_descriptor_write_op* o
+      (static_cast<io_uring_descriptor_write_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, o->ec_, o->bytes_transferred_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_DESCRIPTOR_WRITE_OP_HPP
diff --git a/boost/asio/detail/io_uring_file_service.hpp b/boost/asio/detail/io_uring_file_service.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..d1b97fb3c18a78c25d1dea59f6aba040745f291a
--- /dev/null
+++ b/boost/asio/detail/io_uring_file_service.hpp
@@ -0,0 +1,264 @@
+//
+// detail/io_uring_file_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_FILE_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_FILE_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_FILE) \
+  && defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <string>
+#include <boost/asio/detail/cstdint.hpp>
+#include <boost/asio/detail/descriptor_ops.hpp>
+#include <boost/asio/detail/io_uring_descriptor_service.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/file_base.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Extend the io_uring_descriptor_service to provide file support.
+class io_uring_file_service :
+  public execution_context_service_base<io_uring_file_service>
+{
+public:
+  typedef io_uring_descriptor_service descriptor_service;
+
+  // The native type of a file.
+  typedef descriptor_service::native_handle_type native_handle_type;
+
+  // The implementation type of the file.
+  class implementation_type : descriptor_service::implementation_type
+  {
+  private:
+    // Only this service will have access to the internal values.
+    friend class io_uring_file_service;
+
+    bool is_stream_;
+  };
+
+  BOOST_ASIO_DECL io_uring_file_service(execution_context& context);
+
+  // Destroy all user-defined handler objects owned by the service.
+  BOOST_ASIO_DECL void shutdown();
+
+  // Construct a new file implementation.
+  void construct(implementation_type& impl)
+  {
+    descriptor_service_.construct(impl);
+    impl.is_stream_ = false;
+  }
+
+  // Move-construct a new file implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    descriptor_service_.move_construct(impl, other_impl);
+    impl.is_stream_ = other_impl.is_stream_;
+  }
+
+  // Move-assign from another file implementation.
+  void move_assign(implementation_type& impl,
+      io_uring_file_service& other_service,
+      implementation_type& other_impl)
+  {
+    descriptor_service_.move_assign(impl,
+        other_service.descriptor_service_, other_impl);
+    impl.is_stream_ = other_impl.is_stream_;
+  }
+
+  // Destroy a file implementation.
+  void destroy(implementation_type& impl)
+  {
+    descriptor_service_.destroy(impl);
+  }
+
+  // Open the file using the specified path name.
+  BOOST_ASIO_DECL boost::system::error_code open(implementation_type& impl,
+      const char* path, file_base::flags open_flags,
+      boost::system::error_code& ec);
+
+  // Assign a native descriptor to a file implementation.
+  boost::system::error_code assign(implementation_type& impl,
+      const native_handle_type& native_descriptor,
+      boost::system::error_code& ec)
+  {
+    return descriptor_service_.assign(impl, native_descriptor, ec);
+  }
+
+  // Set whether the implementation is stream-oriented.
+  void set_is_stream(implementation_type& impl, bool is_stream)
+  {
+    impl.is_stream_ = is_stream;
+  }
+
+  // Determine whether the file is open.
+  bool is_open(const implementation_type& impl) const
+  {
+    return descriptor_service_.is_open(impl);
+  }
+
+  // Destroy a file implementation.
+  boost::system::error_code close(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    return descriptor_service_.close(impl, ec);
+  }
+
+  // Get the native file representation.
+  native_handle_type native_handle(const implementation_type& impl) const
+  {
+    return descriptor_service_.native_handle(impl);
+  }
+
+  // Release ownership of the native descriptor representation.
+  native_handle_type release(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    ec = success_ec_;
+    return descriptor_service_.release(impl);
+  }
+
+  // Cancel all operations associated with the file.
+  boost::system::error_code cancel(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    return descriptor_service_.cancel(impl, ec);
+  }
+
+  // Get the size of the file.
+  BOOST_ASIO_DECL uint64_t size(const implementation_type& impl,
+      boost::system::error_code& ec) const;
+
+  // Alter the size of the file.
+  BOOST_ASIO_DECL boost::system::error_code resize(implementation_type& impl,
+      uint64_t n, boost::system::error_code& ec);
+
+  // Synchronise the file to disk.
+  BOOST_ASIO_DECL boost::system::error_code sync_all(implementation_type& impl,
+      boost::system::error_code& ec);
+
+  // Synchronise the file data to disk.
+  BOOST_ASIO_DECL boost::system::error_code sync_data(implementation_type& impl,
+      boost::system::error_code& ec);
+
+  // Seek to a position in the file.
+  BOOST_ASIO_DECL uint64_t seek(implementation_type& impl, int64_t offset,
+      file_base::seek_basis whence, boost::system::error_code& ec);
+
+  // Write the given data. Returns the number of bytes written.
+  template <typename ConstBufferSequence>
+  size_t write_some(implementation_type& impl,
+      const ConstBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    return descriptor_service_.write_some(impl, buffers, ec);
+  }
+
+  // Start an asynchronous write. The data being written must be valid for the
+  // lifetime of the asynchronous operation.
+  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
+  void async_write_some(implementation_type& impl,
+      const ConstBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    descriptor_service_.async_write_some(impl, buffers, handler, io_ex);
+  }
+
+  // Write the given data at the specified location. Returns the number of
+  // bytes written.
+  template <typename ConstBufferSequence>
+  size_t write_some_at(implementation_type& impl, uint64_t offset,
+      const ConstBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    return descriptor_service_.write_some_at(impl, offset, buffers, ec);
+  }
+
+  // Start an asynchronous write at the specified location. The data being
+  // written must be valid for the lifetime of the asynchronous operation.
+  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
+  void async_write_some_at(implementation_type& impl,
+      uint64_t offset, const ConstBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    descriptor_service_.async_write_some_at(
+        impl, offset, buffers, handler, io_ex);
+  }
+
+  // Read some data. Returns the number of bytes read.
+  template <typename MutableBufferSequence>
+  size_t read_some(implementation_type& impl,
+      const MutableBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    return descriptor_service_.read_some(impl, buffers, ec);
+  }
+
+  // Start an asynchronous read. The buffer for the data being read must be
+  // valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence,
+      typename Handler, typename IoExecutor>
+  void async_read_some(implementation_type& impl,
+      const MutableBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    descriptor_service_.async_read_some(impl, buffers, handler, io_ex);
+  }
+
+  // Read some data. Returns the number of bytes read.
+  template <typename MutableBufferSequence>
+  size_t read_some_at(implementation_type& impl, uint64_t offset,
+      const MutableBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    return descriptor_service_.read_some_at(impl, offset, buffers, ec);
+  }
+
+  // Start an asynchronous read. The buffer for the data being read must be
+  // valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence,
+      typename Handler, typename IoExecutor>
+  void async_read_some_at(implementation_type& impl,
+      uint64_t offset, const MutableBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    descriptor_service_.async_read_some_at(
+        impl, offset, buffers, handler, io_ex);
+  }
+
+private:
+  // The implementation used for initiating asynchronous operations.
+  descriptor_service descriptor_service_;
+
+  // Cached success value to avoid accessing category singleton.
+  const boost::system::error_code success_ec_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/detail/impl/io_uring_file_service.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+       //   && defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_FILE_SERVICE_HPP
diff --git a/boost/asio/detail/io_uring_null_buffers_op.hpp b/boost/asio/detail/io_uring_null_buffers_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e363dbfda1d41e742d448d9c4ed162781b77e989
--- /dev/null
+++ b/boost/asio/detail/io_uring_null_buffers_op.hpp
@@ -0,0 +1,113 @@
+//
+// detail/io_uring_null_buffers_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_NULL_BUFFERS_OP_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_NULL_BUFFERS_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_work.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/memory.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Handler, typename IoExecutor>
+class io_uring_null_buffers_op : public io_uring_operation
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_null_buffers_op);
+
+  io_uring_null_buffers_op(const boost::system::error_code& success_ec,
+      int descriptor, int poll_flags, Handler& handler, const IoExecutor& io_ex)
+    : io_uring_operation(success_ec,
+        &io_uring_null_buffers_op::do_prepare,
+        &io_uring_null_buffers_op::do_perform,
+        &io_uring_null_buffers_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex),
+      descriptor_(descriptor),
+      poll_flags_(poll_flags)
+  {
+  }
+
+  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
+  {
+    io_uring_null_buffers_op* o(static_cast<io_uring_null_buffers_op*>(base));
+
+    ::io_uring_prep_poll_add(sqe, o->descriptor_, o->poll_flags_);
+  }
+
+  static bool do_perform(io_uring_operation*, bool after_completion)
+  {
+    return after_completion;
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_null_buffers_op* o(static_cast<io_uring_null_buffers_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, o->ec_, o->bytes_transferred_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+  int descriptor_;
+  int poll_flags_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_NULL_BUFFERS_OP_HPP
diff --git a/boost/asio/detail/io_uring_operation.hpp b/boost/asio/detail/io_uring_operation.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..1451cf61e578d8b640fb8c12834c515d34cbe4cf
--- /dev/null
+++ b/boost/asio/detail/io_uring_operation.hpp
@@ -0,0 +1,86 @@
+//
+// detail/io_uring_operation.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_OPERATION_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_OPERATION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <liburing.h>
+#include <boost/asio/detail/cstdint.hpp>
+#include <boost/asio/detail/operation.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class io_uring_operation
+  : public operation
+{
+public:
+  // The error code to be passed to the completion handler.
+  boost::system::error_code ec_;
+
+  // The number of bytes transferred, to be passed to the completion handler.
+  std::size_t bytes_transferred_;
+
+  // The operation key used for targeted cancellation.
+  void* cancellation_key_;
+
+  // Prepare the operation.
+  void prepare(::io_uring_sqe* sqe)
+  {
+    return prepare_func_(this, sqe);
+  }
+
+  // Perform actions associated with the operation. Returns true when complete.
+  bool perform(bool after_completion)
+  {
+    return perform_func_(this, after_completion);
+  }
+
+protected:
+  typedef void (*prepare_func_type)(io_uring_operation*, ::io_uring_sqe*);
+  typedef bool (*perform_func_type)(io_uring_operation*, bool);
+
+  io_uring_operation(const boost::system::error_code& success_ec,
+      prepare_func_type prepare_func, perform_func_type perform_func,
+      func_type complete_func)
+    : operation(complete_func),
+      ec_(success_ec),
+      bytes_transferred_(0),
+      cancellation_key_(0),
+      prepare_func_(prepare_func),
+      perform_func_(perform_func)
+  {
+  }
+
+private:
+  prepare_func_type prepare_func_;
+  perform_func_type perform_func_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_OPERATION_HPP
diff --git a/boost/asio/detail/io_uring_service.hpp b/boost/asio/detail/io_uring_service.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..8d93d5f8204f9e958437edfaf056cf37db890c96
--- /dev/null
+++ b/boost/asio/detail/io_uring_service.hpp
@@ -0,0 +1,320 @@
+//
+// detail/io_uring_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <liburing.h>
+#include <boost/asio/detail/atomic_count.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/conditionally_enabled_mutex.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/limits.hpp>
+#include <boost/asio/detail/object_pool.hpp>
+#include <boost/asio/detail/op_queue.hpp>
+#include <boost/asio/detail/reactor.hpp>
+#include <boost/asio/detail/scheduler_task.hpp>
+#include <boost/asio/detail/timer_queue_base.hpp>
+#include <boost/asio/detail/timer_queue_set.hpp>
+#include <boost/asio/detail/wait_op.hpp>
+#include <boost/asio/execution_context.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class io_uring_service
+  : public execution_context_service_base<io_uring_service>,
+    public scheduler_task
+{
+private:
+  // The mutex type used by this reactor.
+  typedef conditionally_enabled_mutex mutex;
+
+public:
+  enum op_types { read_op = 0, write_op = 1, except_op = 2, max_ops = 3 };
+
+  class io_object;
+
+  // An I/O queue stores operations that must run serially.
+  class io_queue : operation
+  {
+    friend class io_uring_service;
+
+    io_object* io_object_;
+    op_queue<io_uring_operation> op_queue_;
+    bool cancel_requested_;
+
+    BOOST_ASIO_DECL io_queue();
+    void set_result(int r) { task_result_ = static_cast<unsigned>(r); }
+    BOOST_ASIO_DECL operation* perform_io(int result);
+    BOOST_ASIO_DECL static void do_complete(void* owner, operation* base,
+        const boost::system::error_code& ec, std::size_t bytes_transferred);
+  };
+
+  // Per I/O object state.
+  class io_object
+  {
+    friend class io_uring_service;
+    friend class object_pool_access;
+
+    io_object* next_;
+    io_object* prev_;
+
+    mutex mutex_;
+    io_uring_service* service_;
+    io_queue queues_[max_ops];
+    bool shutdown_;
+
+    BOOST_ASIO_DECL io_object(bool locking);
+  };
+
+  // Per I/O object data.
+  typedef io_object* per_io_object_data;
+
+  // Constructor.
+  BOOST_ASIO_DECL io_uring_service(boost::asio::execution_context& ctx);
+
+  // Destructor.
+  BOOST_ASIO_DECL ~io_uring_service();
+
+  // Destroy all user-defined handler objects owned by the service.
+  BOOST_ASIO_DECL void shutdown();
+
+  // Recreate internal state following a fork.
+  BOOST_ASIO_DECL void notify_fork(
+      boost::asio::execution_context::fork_event fork_ev);
+
+  // Initialise the task.
+  BOOST_ASIO_DECL void init_task();
+
+  // Register an I/O object with io_uring.
+  BOOST_ASIO_DECL void register_io_object(io_object*& io_obj);
+
+  // Register an internal I/O object with io_uring.
+  BOOST_ASIO_DECL void register_internal_io_object(
+      io_object*& io_obj, int op_type, io_uring_operation* op);
+
+  // Register buffers with io_uring.
+  BOOST_ASIO_DECL void register_buffers(const ::iovec* v, unsigned n);
+
+  // Unregister buffers from io_uring.
+  BOOST_ASIO_DECL void unregister_buffers();
+
+  // Post an operation for immediate completion.
+  void post_immediate_completion(operation* op, bool is_continuation);
+
+  // Start a new operation. The operation will be prepared and submitted to the
+  // io_uring when it is at the head of its I/O operation queue.
+  BOOST_ASIO_DECL void start_op(int op_type, per_io_object_data& io_obj,
+      io_uring_operation* op, bool is_continuation);
+
+  // Cancel all operations associated with the given I/O object. The handlers
+  // associated with the I/O object will be invoked with the operation_aborted
+  // error.
+  BOOST_ASIO_DECL void cancel_ops(per_io_object_data& io_obj);
+
+  // Cancel all operations associated with the given I/O object and key. The
+  // handlers associated with the object and key will be invoked with the
+  // operation_aborted error.
+  BOOST_ASIO_DECL void cancel_ops_by_key(per_io_object_data& io_obj,
+      int op_type, void* cancellation_key);
+
+  // Cancel any operations that are running against the I/O object and remove
+  // its registration from the service. The service resources associated with
+  // the I/O object must be released by calling cleanup_io_object.
+  BOOST_ASIO_DECL void deregister_io_object(per_io_object_data& io_obj);
+
+  // Perform any post-deregistration cleanup tasks associated with the I/O
+  // object.
+  BOOST_ASIO_DECL void cleanup_io_object(per_io_object_data& io_obj);
+
+  // Add a new timer queue to the reactor.
+  template <typename Time_Traits>
+  void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
+
+  // Remove a timer queue from the reactor.
+  template <typename Time_Traits>
+  void remove_timer_queue(timer_queue<Time_Traits>& timer_queue);
+
+  // Schedule a new operation in the given timer queue to expire at the
+  // specified absolute time.
+  template <typename Time_Traits>
+  void schedule_timer(timer_queue<Time_Traits>& queue,
+      const typename Time_Traits::time_type& time,
+      typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
+
+  // Cancel the timer operations associated with the given token. Returns the
+  // number of operations that have been posted or dispatched.
+  template <typename Time_Traits>
+  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& timer,
+      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
+
+  // Cancel the timer operations associated with the given key.
+  template <typename Time_Traits>
+  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data* timer,
+      void* cancellation_key);
+
+  // Move the timer operations associated with the given timer.
+  template <typename Time_Traits>
+  void move_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& target,
+      typename timer_queue<Time_Traits>::per_timer_data& source);
+
+  // Wait on io_uring once until interrupted or events are ready to be
+  // dispatched.
+  BOOST_ASIO_DECL void run(long usec, op_queue<operation>& ops);
+
+  // Interrupt the io_uring wait.
+  BOOST_ASIO_DECL void interrupt();
+
+private:
+  // The hint to pass to io_uring_queue_init to size its data structures.
+  enum { ring_size = 16384 };
+
+  // The number of operations to submit in a batch.
+  enum { submit_batch_size = 128 };
+
+  // The number of operations to complete in a batch.
+  enum { complete_batch_size = 128 };
+
+  // The type used for processing eventfd readiness notifications.
+  class event_fd_read_op;
+
+  // Initialise the ring.
+  BOOST_ASIO_DECL void init_ring();
+
+  // Register the eventfd descriptor for readiness notifications.
+  BOOST_ASIO_DECL void register_with_reactor();
+
+  // Allocate a new I/O object.
+  BOOST_ASIO_DECL io_object* allocate_io_object();
+
+  // Free an existing I/O object.
+  BOOST_ASIO_DECL void free_io_object(io_object* s);
+
+  // Helper function to cancel all operations associated with the given I/O
+  // object. This function does not acquire the I/O object's mutex.
+  BOOST_ASIO_DECL void do_cancel_ops(
+      per_io_object_data& io_obj, op_queue<operation>& ops);
+
+  // Helper function to add a new timer queue.
+  BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
+
+  // Helper function to remove a timer queue.
+  BOOST_ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
+
+  // Called to recalculate and update the timeout.
+  BOOST_ASIO_DECL void update_timeout();
+
+  // Get the current timeout value.
+  BOOST_ASIO_DECL __kernel_timespec get_timeout() const;
+
+  // Get a new submission queue entry, flushing the queue if necessary.
+  BOOST_ASIO_DECL ::io_uring_sqe* get_sqe();
+
+  // Submit pending submission queue entries.
+  BOOST_ASIO_DECL void submit_sqes();
+
+  // Post an operation to submit the pending submission queue entries.
+  BOOST_ASIO_DECL void post_submit_sqes_op(mutex::scoped_lock& lock);
+
+  // Push an operation to submit the pending submission queue entries.
+  BOOST_ASIO_DECL void push_submit_sqes_op(op_queue<operation>& ops);
+
+  // Helper operation to submit pending submission queue entries.
+  class submit_sqes_op : operation
+  {
+    friend class io_uring_service;
+
+    io_uring_service* service_;
+
+    BOOST_ASIO_DECL submit_sqes_op(io_uring_service* s);
+    BOOST_ASIO_DECL static void do_complete(void* owner, operation* base,
+        const boost::system::error_code& ec, std::size_t bytes_transferred);
+  };
+
+  // The scheduler implementation used to post completions.
+  scheduler& scheduler_;
+
+  // Mutex to protect access to internal data.
+  mutex mutex_;
+
+  // The ring.
+  ::io_uring ring_;
+
+  // The count of unfinished work.
+  atomic_count outstanding_work_;
+
+  // The operation used to submit the pending submission queue entries.
+  submit_sqes_op submit_sqes_op_;
+
+  // The number of pending submission queue entries_.
+  int pending_sqes_;
+
+  // Whether there is a pending submission operation.
+  bool pending_submit_sqes_op_;
+
+  // Whether the service has been shut down.
+  bool shutdown_;
+
+  // The timer queues.
+  timer_queue_set timer_queues_;
+
+  // The timespec for the pending timeout operation. Must remain valid while the
+  // operation is outstanding.
+  __kernel_timespec timeout_;
+
+  // Mutex to protect access to the registered I/O objects.
+  mutex registration_mutex_;
+
+  // Keep track of all registered I/O objects.
+  object_pool<io_object> registered_io_objects_;
+
+  // Helper class to do post-perform_io cleanup.
+  struct perform_io_cleanup_on_block_exit;
+  friend struct perform_io_cleanup_on_block_exit;
+
+  // The reactor used to register for eventfd readiness.
+  reactor& reactor_;
+
+  // The per-descriptor reactor data used for the eventfd.
+  reactor::per_descriptor_data reactor_data_;
+
+  // The eventfd descriptor used to wait for readiness.
+  int event_fd_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/impl/io_uring_service.hpp>
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/detail/impl/io_uring_service.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_SERVICE_HPP
diff --git a/boost/asio/detail/io_uring_socket_accept_op.hpp b/boost/asio/detail/io_uring_socket_accept_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..032f63f78d6e162ce85fb9679fd335b1cac49d4e
--- /dev/null
+++ b/boost/asio/detail/io_uring_socket_accept_op.hpp
@@ -0,0 +1,279 @@
+//
+// detail/io_uring_socket_accept_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_SOCKET_ACCEPT_OP_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_SOCKET_ACCEPT_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_work.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/memory.hpp>
+#include <boost/asio/detail/socket_holder.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Socket, typename Protocol>
+class io_uring_socket_accept_op_base : public io_uring_operation
+{
+public:
+  io_uring_socket_accept_op_base(const boost::system::error_code& success_ec,
+      socket_type socket, socket_ops::state_type state, Socket& peer,
+      const Protocol& protocol, typename Protocol::endpoint* peer_endpoint,
+      func_type complete_func)
+    : io_uring_operation(success_ec,
+        &io_uring_socket_accept_op_base::do_prepare,
+        &io_uring_socket_accept_op_base::do_perform, complete_func),
+      socket_(socket),
+      state_(state),
+      peer_(peer),
+      protocol_(protocol),
+      peer_endpoint_(peer_endpoint),
+      addrlen_(peer_endpoint ? peer_endpoint->capacity() : 0)
+  {
+  }
+
+  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
+  {
+    io_uring_socket_accept_op_base* o(
+        static_cast<io_uring_socket_accept_op_base*>(base));
+
+    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
+    {
+      ::io_uring_prep_poll_add(sqe, o->socket_, POLLIN);
+    }
+    else
+    {
+      ::io_uring_prep_accept(sqe, o->socket_,
+          o->peer_endpoint_ ? o->peer_endpoint_->data() : 0,
+          o->peer_endpoint_ ? &o->addrlen_ : 0, 0);
+    }
+  }
+
+  static bool do_perform(io_uring_operation* base, bool after_completion)
+  {
+    io_uring_socket_accept_op_base* o(
+        static_cast<io_uring_socket_accept_op_base*>(base));
+
+    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
+    {
+      socket_type new_socket = invalid_socket;
+      std::size_t addrlen = static_cast<std::size_t>(o->addrlen_);
+      bool result = socket_ops::non_blocking_accept(o->socket_,
+          o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data() : 0,
+          o->peer_endpoint_ ? &addrlen : 0, o->ec_, new_socket);
+      o->new_socket_.reset(new_socket);
+      o->addrlen_ = static_cast<socklen_t>(addrlen);
+      return result;
+    }
+
+    if (o->ec_ && o->ec_ == boost::asio::error::would_block)
+    {
+      o->state_ |= socket_ops::internal_non_blocking;
+      return false;
+    }
+
+    if (after_completion && !o->ec_)
+      o->new_socket_.reset(static_cast<int>(o->bytes_transferred_));
+
+    return after_completion;
+  }
+
+  void do_assign()
+  {
+    if (new_socket_.get() != invalid_socket)
+    {
+      if (peer_endpoint_)
+        peer_endpoint_->resize(addrlen_);
+      peer_.assign(protocol_, new_socket_.get(), ec_);
+      if (!ec_)
+        new_socket_.release();
+    }
+  }
+
+private:
+  socket_type socket_;
+  socket_ops::state_type state_;
+  socket_holder new_socket_;
+  Socket& peer_;
+  Protocol protocol_;
+  typename Protocol::endpoint* peer_endpoint_;
+  socklen_t addrlen_;
+};
+
+template <typename Socket, typename Protocol,
+    typename Handler, typename IoExecutor>
+class io_uring_socket_accept_op :
+  public io_uring_socket_accept_op_base<Socket, Protocol>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_socket_accept_op);
+
+  io_uring_socket_accept_op(const boost::system::error_code& success_ec,
+      socket_type socket, socket_ops::state_type state, Socket& peer,
+      const Protocol& protocol, typename Protocol::endpoint* peer_endpoint,
+      Handler& handler, const IoExecutor& io_ex)
+    : io_uring_socket_accept_op_base<Socket, Protocol>(
+        success_ec, socket, state, peer, protocol, peer_endpoint,
+        &io_uring_socket_accept_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_socket_accept_op* o(static_cast<io_uring_socket_accept_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    // On success, assign new connection to peer socket object.
+    if (owner)
+      o->do_assign();
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder1<Handler, boost::system::error_code>
+      handler(o->handler_, o->ec_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+};
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+
+template <typename Protocol, typename PeerIoExecutor,
+    typename Handler, typename IoExecutor>
+class io_uring_socket_move_accept_op :
+  private Protocol::socket::template rebind_executor<PeerIoExecutor>::other,
+  public io_uring_socket_accept_op_base<
+    typename Protocol::socket::template rebind_executor<PeerIoExecutor>::other,
+    Protocol>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_socket_move_accept_op);
+
+  io_uring_socket_move_accept_op(const boost::system::error_code& success_ec,
+      const PeerIoExecutor& peer_io_ex, socket_type socket,
+      socket_ops::state_type state, const Protocol& protocol,
+      typename Protocol::endpoint* peer_endpoint, Handler& handler,
+      const IoExecutor& io_ex)
+    : peer_socket_type(peer_io_ex),
+      io_uring_socket_accept_op_base<peer_socket_type, Protocol>(
+        success_ec, socket, state, *this, protocol, peer_endpoint,
+        &io_uring_socket_move_accept_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_socket_move_accept_op* o(
+        static_cast<io_uring_socket_move_accept_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    // On success, assign new connection to peer socket object.
+    if (owner)
+      o->do_assign();
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::move_binder2<Handler,
+      boost::system::error_code, peer_socket_type>
+        handler(0, BOOST_ASIO_MOVE_CAST(Handler)(o->handler_), o->ec_,
+          BOOST_ASIO_MOVE_CAST(peer_socket_type)(*o));
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  typedef typename Protocol::socket::template
+    rebind_executor<PeerIoExecutor>::other peer_socket_type;
+
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+};
+
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_SOCKET_ACCEPT_OP_HPP
diff --git a/boost/asio/detail/io_uring_socket_connect_op.hpp b/boost/asio/detail/io_uring_socket_connect_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..53ba5fbbd695d2e122452a73bbde8771cdd172c0
--- /dev/null
+++ b/boost/asio/detail/io_uring_socket_connect_op.hpp
@@ -0,0 +1,139 @@
+//
+// detail/io_uring_socket_connect_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_SOCKET_CONNECT_OP_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_SOCKET_CONNECT_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_work.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/memory.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Protocol>
+class io_uring_socket_connect_op_base : public io_uring_operation
+{
+public:
+  io_uring_socket_connect_op_base(const boost::system::error_code& success_ec,
+      socket_type socket, const typename Protocol::endpoint& endpoint,
+      func_type complete_func)
+    : io_uring_operation(success_ec,
+        &io_uring_socket_connect_op_base::do_prepare,
+        &io_uring_socket_connect_op_base::do_perform, complete_func),
+      socket_(socket),
+      endpoint_(endpoint)
+  {
+  }
+
+  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
+  {
+    io_uring_socket_connect_op_base* o(
+        static_cast<io_uring_socket_connect_op_base*>(base));
+
+    ::io_uring_prep_connect(sqe, o->socket_,
+        static_cast<sockaddr*>(o->endpoint_.data()),
+        static_cast<socklen_t>(o->endpoint_.size()));
+  }
+
+  static bool do_perform(io_uring_operation*, bool after_completion)
+  {
+    return after_completion;
+  }
+
+private:
+  socket_type socket_;
+  typename Protocol::endpoint endpoint_;
+};
+
+template <typename Protocol, typename Handler, typename IoExecutor>
+class io_uring_socket_connect_op :
+  public io_uring_socket_connect_op_base<Protocol>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_socket_connect_op);
+
+  io_uring_socket_connect_op(const boost::system::error_code& success_ec,
+      socket_type socket, const typename Protocol::endpoint& endpoint,
+      Handler& handler, const IoExecutor& io_ex)
+    : io_uring_socket_connect_op_base<Protocol>(success_ec, socket,
+        endpoint, &io_uring_socket_connect_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_socket_connect_op* o
+      (static_cast<io_uring_socket_connect_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder1<Handler, boost::system::error_code>
+      handler(o->handler_, o->ec_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_SOCKET_CONNECT_OP_HPP
diff --git a/boost/asio/detail/io_uring_socket_recv_op.hpp b/boost/asio/detail/io_uring_socket_recv_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a7825248c8758d741d8fde1afe4c69146ae18663
--- /dev/null
+++ b/boost/asio/detail/io_uring_socket_recv_op.hpp
@@ -0,0 +1,202 @@
+//
+// detail/io_uring_socket_recv_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_SOCKET_RECV_OP_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_SOCKET_RECV_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_work.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/memory.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename MutableBufferSequence>
+class io_uring_socket_recv_op_base : public io_uring_operation
+{
+public:
+  io_uring_socket_recv_op_base(const boost::system::error_code& success_ec,
+      socket_type socket, socket_ops::state_type state,
+      const MutableBufferSequence& buffers,
+      socket_base::message_flags flags, func_type complete_func)
+    : io_uring_operation(success_ec,
+        &io_uring_socket_recv_op_base::do_prepare,
+        &io_uring_socket_recv_op_base::do_perform, complete_func),
+      socket_(socket),
+      state_(state),
+      buffers_(buffers),
+      flags_(flags),
+      bufs_(buffers),
+      msghdr_()
+  {
+    msghdr_.msg_iov = bufs_.buffers();
+    msghdr_.msg_iovlen = static_cast<int>(bufs_.count());
+  }
+
+  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
+  {
+    io_uring_socket_recv_op_base* o(
+        static_cast<io_uring_socket_recv_op_base*>(base));
+
+    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
+    {
+      bool except_op = (o->flags_ & socket_base::message_out_of_band) != 0;
+      ::io_uring_prep_poll_add(sqe, o->socket_, except_op ? POLLPRI : POLLIN);
+    }
+    else if (o->bufs_.is_single_buffer
+        && o->bufs_.is_registered_buffer && o->flags_ == 0)
+    {
+      ::io_uring_prep_read_fixed(sqe, o->socket_,
+          o->bufs_.buffers()->iov_base, o->bufs_.buffers()->iov_len,
+          0, o->bufs_.registered_id().native_handle());
+    }
+    else
+    {
+      ::io_uring_prep_recvmsg(sqe, o->socket_, &o->msghdr_, o->flags_);
+    }
+  }
+
+  static bool do_perform(io_uring_operation* base, bool after_completion)
+  {
+    io_uring_socket_recv_op_base* o(
+        static_cast<io_uring_socket_recv_op_base*>(base));
+
+    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
+    {
+      bool except_op = (o->flags_ & socket_base::message_out_of_band) != 0;
+      if (after_completion || !except_op)
+      {
+        if (o->bufs_.is_single_buffer)
+        {
+          return socket_ops::non_blocking_recv1(o->socket_,
+              o->bufs_.first(o->buffers_).data(),
+              o->bufs_.first(o->buffers_).size(), o->flags_,
+              (o->state_ & socket_ops::stream_oriented) != 0,
+              o->ec_, o->bytes_transferred_);
+        }
+        else
+        {
+          return socket_ops::non_blocking_recv(o->socket_,
+              o->bufs_.buffers(), o->bufs_.count(), o->flags_,
+              (o->state_ & socket_ops::stream_oriented) != 0,
+              o->ec_, o->bytes_transferred_);
+        }
+      }
+    }
+    else if (after_completion)
+    {
+      if (!o->ec_ && o->bytes_transferred_ == 0)
+        if ((o->state_ & socket_ops::stream_oriented) != 0)
+          o->ec_ = boost::asio::error::eof;
+    }
+
+    if (o->ec_ && o->ec_ == boost::asio::error::would_block)
+    {
+      o->state_ |= socket_ops::internal_non_blocking;
+      return false;
+    }
+
+    return after_completion;
+  }
+
+private:
+  socket_type socket_;
+  socket_ops::state_type state_;
+  MutableBufferSequence buffers_;
+  socket_base::message_flags flags_;
+  buffer_sequence_adapter<boost::asio::mutable_buffer,
+      MutableBufferSequence> bufs_;
+  msghdr msghdr_;
+};
+
+template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
+class io_uring_socket_recv_op
+  : public io_uring_socket_recv_op_base<MutableBufferSequence>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_socket_recv_op);
+
+  io_uring_socket_recv_op(const boost::system::error_code& success_ec,
+      int socket, socket_ops::state_type state,
+      const MutableBufferSequence& buffers, socket_base::message_flags flags,
+      Handler& handler, const IoExecutor& io_ex)
+    : io_uring_socket_recv_op_base<MutableBufferSequence>(success_ec,
+        socket, state, buffers, flags, &io_uring_socket_recv_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_socket_recv_op* o
+      (static_cast<io_uring_socket_recv_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, o->ec_, o->bytes_transferred_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_SOCKET_RECV_OP_HPP
diff --git a/boost/asio/detail/io_uring_socket_recvfrom_op.hpp b/boost/asio/detail/io_uring_socket_recvfrom_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..1f12d8df71cafd2f01e60245baabfa36e779c7bc
--- /dev/null
+++ b/boost/asio/detail/io_uring_socket_recvfrom_op.hpp
@@ -0,0 +1,203 @@
+//
+// detail/io_uring_socket_recvfrom_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_SOCKET_RECVFROM_OP_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_SOCKET_RECVFROM_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_work.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/memory.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename MutableBufferSequence, typename Endpoint>
+class io_uring_socket_recvfrom_op_base : public io_uring_operation
+{
+public:
+  io_uring_socket_recvfrom_op_base(const boost::system::error_code& success_ec,
+      socket_type socket, socket_ops::state_type state,
+      const MutableBufferSequence& buffers, Endpoint& endpoint,
+      socket_base::message_flags flags, func_type complete_func)
+    : io_uring_operation(success_ec,
+        &io_uring_socket_recvfrom_op_base::do_prepare,
+        &io_uring_socket_recvfrom_op_base::do_perform, complete_func),
+      socket_(socket),
+      state_(state),
+      buffers_(buffers),
+      sender_endpoint_(endpoint),
+      flags_(flags),
+      bufs_(buffers),
+      msghdr_()
+  {
+    msghdr_.msg_iov = bufs_.buffers();
+    msghdr_.msg_iovlen = static_cast<int>(bufs_.count());
+    msghdr_.msg_name = static_cast<sockaddr*>(
+        static_cast<void*>(sender_endpoint_.data()));
+    msghdr_.msg_namelen = sender_endpoint_.capacity();
+  }
+
+  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
+  {
+    io_uring_socket_recvfrom_op_base* o(
+        static_cast<io_uring_socket_recvfrom_op_base*>(base));
+
+    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
+    {
+      bool except_op = (o->flags_ & socket_base::message_out_of_band) != 0;
+      ::io_uring_prep_poll_add(sqe, o->socket_, except_op ? POLLPRI : POLLIN);
+    }
+    else
+    {
+      ::io_uring_prep_recvmsg(sqe, o->socket_, &o->msghdr_, o->flags_);
+    }
+  }
+
+  static bool do_perform(io_uring_operation* base, bool after_completion)
+  {
+    io_uring_socket_recvfrom_op_base* o(
+        static_cast<io_uring_socket_recvfrom_op_base*>(base));
+
+    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
+    {
+      bool except_op = (o->flags_ & socket_base::message_out_of_band) != 0;
+      if (after_completion || !except_op)
+      {
+        std::size_t addr_len = o->sender_endpoint_.capacity();
+        bool result;
+        if (o->bufs_.is_single_buffer)
+        {
+          result = socket_ops::non_blocking_recvfrom1(o->socket_,
+              o->bufs_.first(o->buffers_).data(),
+              o->bufs_.first(o->buffers_).size(), o->flags_,
+              o->sender_endpoint_.data(), &addr_len,
+              o->ec_, o->bytes_transferred_);
+        }
+        else
+        {
+          result = socket_ops::non_blocking_recvfrom(o->socket_,
+              o->bufs_.buffers(), o->bufs_.count(), o->flags_,
+              o->sender_endpoint_.data(), &addr_len,
+              o->ec_, o->bytes_transferred_);
+        }
+        if (result && !o->ec_)
+          o->sender_endpoint_.resize(addr_len);
+      }
+    }
+    else if (after_completion && !o->ec_)
+      o->sender_endpoint_.resize(o->msghdr_.msg_namelen);
+
+    if (o->ec_ && o->ec_ == boost::asio::error::would_block)
+    {
+      o->state_ |= socket_ops::internal_non_blocking;
+      return false;
+    }
+
+    return after_completion;
+  }
+
+private:
+  socket_type socket_;
+  socket_ops::state_type state_;
+  MutableBufferSequence buffers_;
+  Endpoint& sender_endpoint_;
+  socket_base::message_flags flags_;
+  buffer_sequence_adapter<boost::asio::mutable_buffer,
+      MutableBufferSequence> bufs_;
+  msghdr msghdr_;
+};
+
+template <typename MutableBufferSequence, typename Endpoint,
+    typename Handler, typename IoExecutor>
+class io_uring_socket_recvfrom_op
+  : public io_uring_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_socket_recvfrom_op);
+
+  io_uring_socket_recvfrom_op(const boost::system::error_code& success_ec,
+      int socket, socket_ops::state_type state,
+      const MutableBufferSequence& buffers, Endpoint& endpoint,
+      socket_base::message_flags flags,
+      Handler& handler, const IoExecutor& io_ex)
+    : io_uring_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>(
+        success_ec, socket, state, buffers, endpoint, flags,
+        &io_uring_socket_recvfrom_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_socket_recvfrom_op* o
+      (static_cast<io_uring_socket_recvfrom_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, o->ec_, o->bytes_transferred_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_SOCKET_RECVFROM_OP_HPP
diff --git a/boost/asio/detail/io_uring_socket_recvmsg_op.hpp b/boost/asio/detail/io_uring_socket_recvmsg_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..8e468c4a015843a9a0207acd215de3a85b2d3af1
--- /dev/null
+++ b/boost/asio/detail/io_uring_socket_recvmsg_op.hpp
@@ -0,0 +1,189 @@
+//
+// detail/io_uring_socket_recvmsg_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_SOCKET_RECVMSG_OP_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_SOCKET_RECVMSG_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_work.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/memory.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename MutableBufferSequence>
+class io_uring_socket_recvmsg_op_base : public io_uring_operation
+{
+public:
+  io_uring_socket_recvmsg_op_base(const boost::system::error_code& success_ec,
+      socket_type socket, socket_ops::state_type state,
+      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, func_type complete_func)
+    : io_uring_operation(success_ec,
+        &io_uring_socket_recvmsg_op_base::do_prepare,
+        &io_uring_socket_recvmsg_op_base::do_perform, complete_func),
+      socket_(socket),
+      state_(state),
+      buffers_(buffers),
+      in_flags_(in_flags),
+      out_flags_(out_flags),
+      bufs_(buffers),
+      msghdr_()
+  {
+    msghdr_.msg_iov = bufs_.buffers();
+    msghdr_.msg_iovlen = static_cast<int>(bufs_.count());
+  }
+
+  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
+  {
+    io_uring_socket_recvmsg_op_base* o(
+        static_cast<io_uring_socket_recvmsg_op_base*>(base));
+
+    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
+    {
+      bool except_op = (o->in_flags_ & socket_base::message_out_of_band) != 0;
+      ::io_uring_prep_poll_add(sqe, o->socket_, except_op ? POLLPRI : POLLIN);
+    }
+    else
+    {
+      ::io_uring_prep_recvmsg(sqe, o->socket_, &o->msghdr_, o->in_flags_);
+    }
+  }
+
+  static bool do_perform(io_uring_operation* base, bool after_completion)
+  {
+    io_uring_socket_recvmsg_op_base* o(
+        static_cast<io_uring_socket_recvmsg_op_base*>(base));
+
+    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
+    {
+      bool except_op = (o->in_flags_ & socket_base::message_out_of_band) != 0;
+      if (after_completion || !except_op)
+      {
+        return socket_ops::non_blocking_recvmsg(o->socket_,
+            o->bufs_.buffers(), o->bufs_.count(), o->in_flags_,
+            o->out_flags_, o->ec_, o->bytes_transferred_);
+      }
+    }
+    else if (after_completion)
+    {
+      if (!o->ec_)
+        o->out_flags_ = o->msghdr_.msg_flags;
+      else
+        o->out_flags_ = 0;
+    }
+
+    if (o->ec_ && o->ec_ == boost::asio::error::would_block)
+    {
+      o->state_ |= socket_ops::internal_non_blocking;
+      return false;
+    }
+
+    return after_completion;
+  }
+
+private:
+  socket_type socket_;
+  socket_ops::state_type state_;
+  MutableBufferSequence buffers_;
+  socket_base::message_flags in_flags_;
+  socket_base::message_flags& out_flags_;
+  buffer_sequence_adapter<boost::asio::mutable_buffer,
+      MutableBufferSequence> bufs_;
+  msghdr msghdr_;
+};
+
+template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
+class io_uring_socket_recvmsg_op
+  : public io_uring_socket_recvmsg_op_base<MutableBufferSequence>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_socket_recvmsg_op);
+
+  io_uring_socket_recvmsg_op(const boost::system::error_code& success_ec,
+      int socket, socket_ops::state_type state,
+      const MutableBufferSequence& buffers,
+      socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags,
+      Handler& handler, const IoExecutor& io_ex)
+    : io_uring_socket_recvmsg_op_base<MutableBufferSequence>(success_ec,
+        socket, state, buffers, in_flags, out_flags,
+        &io_uring_socket_recvmsg_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_socket_recvmsg_op* o
+      (static_cast<io_uring_socket_recvmsg_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, o->ec_, o->bytes_transferred_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_SOCKET_RECVMSG_OP_HPP
diff --git a/boost/asio/detail/io_uring_socket_send_op.hpp b/boost/asio/detail/io_uring_socket_send_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c4d0967a1644338ee251de7bf483ba29c7ccbd09
--- /dev/null
+++ b/boost/asio/detail/io_uring_socket_send_op.hpp
@@ -0,0 +1,188 @@
+//
+// detail/io_uring_socket_send_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_SOCKET_SEND_OP_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_SOCKET_SEND_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_work.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/memory.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename ConstBufferSequence>
+class io_uring_socket_send_op_base : public io_uring_operation
+{
+public:
+  io_uring_socket_send_op_base(const boost::system::error_code& success_ec,
+      socket_type socket, socket_ops::state_type state,
+      const ConstBufferSequence& buffers,
+      socket_base::message_flags flags, func_type complete_func)
+    : io_uring_operation(success_ec,
+        &io_uring_socket_send_op_base::do_prepare,
+        &io_uring_socket_send_op_base::do_perform, complete_func),
+      socket_(socket),
+      state_(state),
+      buffers_(buffers),
+      flags_(flags),
+      bufs_(buffers),
+      msghdr_()
+  {
+    msghdr_.msg_iov = bufs_.buffers();
+    msghdr_.msg_iovlen = static_cast<int>(bufs_.count());
+  }
+
+  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
+  {
+    io_uring_socket_send_op_base* o(
+        static_cast<io_uring_socket_send_op_base*>(base));
+
+    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
+    {
+      ::io_uring_prep_poll_add(sqe, o->socket_, POLLOUT);
+    }
+    else if (o->bufs_.is_single_buffer
+        && o->bufs_.is_registered_buffer && o->flags_ == 0)
+    {
+      ::io_uring_prep_write_fixed(sqe, o->socket_,
+          o->bufs_.buffers()->iov_base, o->bufs_.buffers()->iov_len,
+          0, o->bufs_.registered_id().native_handle());
+    }
+    else
+    {
+      ::io_uring_prep_sendmsg(sqe, o->socket_, &o->msghdr_, o->flags_);
+    }
+  }
+
+  static bool do_perform(io_uring_operation* base, bool after_completion)
+  {
+    io_uring_socket_send_op_base* o(
+        static_cast<io_uring_socket_send_op_base*>(base));
+
+    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
+    {
+      if (o->bufs_.is_single_buffer)
+      {
+        return socket_ops::non_blocking_send1(o->socket_,
+            o->bufs_.first(o->buffers_).data(),
+            o->bufs_.first(o->buffers_).size(), o->flags_,
+            o->ec_, o->bytes_transferred_);
+      }
+      else
+      {
+        return socket_ops::non_blocking_send(o->socket_,
+            o->bufs_.buffers(), o->bufs_.count(), o->flags_,
+            o->ec_, o->bytes_transferred_);
+      }
+    }
+
+    if (o->ec_ && o->ec_ == boost::asio::error::would_block)
+    {
+      o->state_ |= socket_ops::internal_non_blocking;
+      return false;
+    }
+
+    return after_completion;
+  }
+
+private:
+  socket_type socket_;
+  socket_ops::state_type state_;
+  ConstBufferSequence buffers_;
+  socket_base::message_flags flags_;
+  buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence> bufs_;
+  msghdr msghdr_;
+};
+
+template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
+class io_uring_socket_send_op
+  : public io_uring_socket_send_op_base<ConstBufferSequence>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_socket_send_op);
+
+  io_uring_socket_send_op(const boost::system::error_code& success_ec,
+      int socket, socket_ops::state_type state,
+      const ConstBufferSequence& buffers, socket_base::message_flags flags,
+      Handler& handler, const IoExecutor& io_ex)
+    : io_uring_socket_send_op_base<ConstBufferSequence>(success_ec,
+        socket, state, buffers, flags, &io_uring_socket_send_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_socket_send_op* o
+      (static_cast<io_uring_socket_send_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, o->ec_, o->bytes_transferred_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_SOCKET_SEND_OP_HPP
diff --git a/boost/asio/detail/io_uring_socket_sendto_op.hpp b/boost/asio/detail/io_uring_socket_sendto_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..dd383299e00703dff295900a3414b5f4fd8d81f4
--- /dev/null
+++ b/boost/asio/detail/io_uring_socket_sendto_op.hpp
@@ -0,0 +1,191 @@
+//
+// detail/io_uring_socket_sendto_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_SOCKET_SENDTO_OP_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_SOCKET_SENDTO_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_work.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/memory.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename ConstBufferSequence, typename Endpoint>
+class io_uring_socket_sendto_op_base : public io_uring_operation
+{
+public:
+  io_uring_socket_sendto_op_base(const boost::system::error_code& success_ec,
+      socket_type socket, socket_ops::state_type state,
+      const ConstBufferSequence& buffers, const Endpoint& endpoint,
+      socket_base::message_flags flags, func_type complete_func)
+    : io_uring_operation(success_ec,
+        &io_uring_socket_sendto_op_base::do_prepare,
+        &io_uring_socket_sendto_op_base::do_perform, complete_func),
+      socket_(socket),
+      state_(state),
+      buffers_(buffers),
+      destination_(endpoint),
+      flags_(flags),
+      bufs_(buffers),
+      msghdr_()
+  {
+    msghdr_.msg_iov = bufs_.buffers();
+    msghdr_.msg_iovlen = static_cast<int>(bufs_.count());
+    msghdr_.msg_name = static_cast<sockaddr*>(
+        static_cast<void*>(destination_.data()));
+    msghdr_.msg_namelen = destination_.size();
+  }
+
+  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
+  {
+    io_uring_socket_sendto_op_base* o(
+        static_cast<io_uring_socket_sendto_op_base*>(base));
+
+    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
+    {
+      ::io_uring_prep_poll_add(sqe, o->socket_, POLLOUT);
+    }
+    else
+    {
+      ::io_uring_prep_sendmsg(sqe, o->socket_, &o->msghdr_, o->flags_);
+    }
+  }
+
+  static bool do_perform(io_uring_operation* base, bool after_completion)
+  {
+    io_uring_socket_sendto_op_base* o(
+        static_cast<io_uring_socket_sendto_op_base*>(base));
+
+    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
+    {
+      if (o->bufs_.is_single_buffer)
+      {
+        return socket_ops::non_blocking_sendto1(o->socket_,
+            o->bufs_.first(o->buffers_).data(),
+            o->bufs_.first(o->buffers_).size(), o->flags_,
+            o->destination_.data(), o->destination_.size(),
+            o->ec_, o->bytes_transferred_);
+      }
+      else
+      {
+        return socket_ops::non_blocking_sendto(o->socket_,
+            o->bufs_.buffers(), o->bufs_.count(), o->flags_,
+            o->destination_.data(), o->destination_.size(),
+            o->ec_, o->bytes_transferred_);
+      }
+    }
+
+    if (o->ec_ && o->ec_ == boost::asio::error::would_block)
+    {
+      o->state_ |= socket_ops::internal_non_blocking;
+      return false;
+    }
+
+    return after_completion;
+  }
+
+private:
+  socket_type socket_;
+  socket_ops::state_type state_;
+  ConstBufferSequence buffers_;
+  Endpoint destination_;
+  socket_base::message_flags flags_;
+  buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence> bufs_;
+  msghdr msghdr_;
+};
+
+template <typename ConstBufferSequence, typename Endpoint,
+    typename Handler, typename IoExecutor>
+class io_uring_socket_sendto_op
+  : public io_uring_socket_sendto_op_base<ConstBufferSequence, Endpoint>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_socket_sendto_op);
+
+  io_uring_socket_sendto_op(const boost::system::error_code& success_ec,
+      int socket, socket_ops::state_type state,
+      const ConstBufferSequence& buffers, const Endpoint& endpoint,
+      socket_base::message_flags flags,
+      Handler& handler, const IoExecutor& io_ex)
+    : io_uring_socket_sendto_op_base<ConstBufferSequence, Endpoint>(
+        success_ec, socket, state, buffers, endpoint, flags,
+        &io_uring_socket_sendto_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_socket_sendto_op* o
+      (static_cast<io_uring_socket_sendto_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, o->ec_, o->bytes_transferred_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_SOCKET_SENDTO_OP_HPP
diff --git a/boost/asio/detail/io_uring_socket_service.hpp b/boost/asio/detail/io_uring_socket_service.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c0a731590316433c4ab7f4ee5a8285159d9d8f26
--- /dev/null
+++ b/boost/asio/detail/io_uring_socket_service.hpp
@@ -0,0 +1,615 @@
+//
+// detail/io_uring_socket_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_SOCKET_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_SOCKET_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/socket_base.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/memory.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/io_uring_null_buffers_op.hpp>
+#include <boost/asio/detail/io_uring_service.hpp>
+#include <boost/asio/detail/io_uring_socket_accept_op.hpp>
+#include <boost/asio/detail/io_uring_socket_connect_op.hpp>
+#include <boost/asio/detail/io_uring_socket_recvfrom_op.hpp>
+#include <boost/asio/detail/io_uring_socket_sendto_op.hpp>
+#include <boost/asio/detail/io_uring_socket_service_base.hpp>
+#include <boost/asio/detail/socket_holder.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Protocol>
+class io_uring_socket_service :
+  public execution_context_service_base<io_uring_socket_service<Protocol> >,
+  public io_uring_socket_service_base
+{
+public:
+  // The protocol type.
+  typedef Protocol protocol_type;
+
+  // The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  // The native type of a socket.
+  typedef socket_type native_handle_type;
+
+  // The implementation type of the socket.
+  struct implementation_type :
+    io_uring_socket_service_base::base_implementation_type
+  {
+    // Default constructor.
+    implementation_type()
+      : protocol_(endpoint_type().protocol())
+    {
+    }
+
+    // The protocol associated with the socket.
+    protocol_type protocol_;
+  };
+
+  // Constructor.
+  io_uring_socket_service(execution_context& context)
+    : execution_context_service_base<
+        io_uring_socket_service<Protocol> >(context),
+      io_uring_socket_service_base(context)
+  {
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown()
+  {
+    this->base_shutdown();
+  }
+
+  // Move-construct a new socket implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl) BOOST_ASIO_NOEXCEPT
+  {
+    this->base_move_construct(impl, other_impl);
+
+    impl.protocol_ = other_impl.protocol_;
+    other_impl.protocol_ = endpoint_type().protocol();
+  }
+
+  // Move-assign from another socket implementation.
+  void move_assign(implementation_type& impl,
+      io_uring_socket_service_base& other_service,
+      implementation_type& other_impl)
+  {
+    this->base_move_assign(impl, other_service, other_impl);
+
+    impl.protocol_ = other_impl.protocol_;
+    other_impl.protocol_ = endpoint_type().protocol();
+  }
+
+  // Move-construct a new socket implementation from another protocol type.
+  template <typename Protocol1>
+  void converting_move_construct(implementation_type& impl,
+      io_uring_socket_service<Protocol1>&,
+      typename io_uring_socket_service<
+        Protocol1>::implementation_type& other_impl)
+  {
+    this->base_move_construct(impl, other_impl);
+
+    impl.protocol_ = protocol_type(other_impl.protocol_);
+    other_impl.protocol_ = typename Protocol1::endpoint().protocol();
+  }
+
+  // Open a new socket implementation.
+  boost::system::error_code open(implementation_type& impl,
+      const protocol_type& protocol, boost::system::error_code& ec)
+  {
+    if (!do_open(impl, protocol.family(),
+          protocol.type(), protocol.protocol(), ec))
+      impl.protocol_ = protocol;
+    return ec;
+  }
+
+  // Assign a native socket to a socket implementation.
+  boost::system::error_code assign(implementation_type& impl,
+      const protocol_type& protocol, const native_handle_type& native_socket,
+      boost::system::error_code& ec)
+  {
+    if (!do_assign(impl, protocol.type(), native_socket, ec))
+      impl.protocol_ = protocol;
+    return ec;
+  }
+
+  // Get the native socket representation.
+  native_handle_type native_handle(implementation_type& impl)
+  {
+    return impl.socket_;
+  }
+
+  // Bind the socket to the specified local endpoint.
+  boost::system::error_code bind(implementation_type& impl,
+      const endpoint_type& endpoint, boost::system::error_code& ec)
+  {
+    socket_ops::bind(impl.socket_, endpoint.data(), endpoint.size(), ec);
+    return ec;
+  }
+
+  // Set a socket option.
+  template <typename Option>
+  boost::system::error_code set_option(implementation_type& impl,
+      const Option& option, boost::system::error_code& ec)
+  {
+    socket_ops::setsockopt(impl.socket_, impl.state_,
+        option.level(impl.protocol_), option.name(impl.protocol_),
+        option.data(impl.protocol_), option.size(impl.protocol_), ec);
+    return ec;
+  }
+
+  // Set a socket option.
+  template <typename Option>
+  boost::system::error_code get_option(const implementation_type& impl,
+      Option& option, boost::system::error_code& ec) const
+  {
+    std::size_t size = option.size(impl.protocol_);
+    socket_ops::getsockopt(impl.socket_, impl.state_,
+        option.level(impl.protocol_), option.name(impl.protocol_),
+        option.data(impl.protocol_), &size, ec);
+    if (!ec)
+      option.resize(impl.protocol_, size);
+    return ec;
+  }
+
+  // Get the local endpoint.
+  endpoint_type local_endpoint(const implementation_type& impl,
+      boost::system::error_code& ec) const
+  {
+    endpoint_type endpoint;
+    std::size_t addr_len = endpoint.capacity();
+    if (socket_ops::getsockname(impl.socket_, endpoint.data(), &addr_len, ec))
+      return endpoint_type();
+    endpoint.resize(addr_len);
+    return endpoint;
+  }
+
+  // Get the remote endpoint.
+  endpoint_type remote_endpoint(const implementation_type& impl,
+      boost::system::error_code& ec) const
+  {
+    endpoint_type endpoint;
+    std::size_t addr_len = endpoint.capacity();
+    if (socket_ops::getpeername(impl.socket_,
+          endpoint.data(), &addr_len, false, ec))
+      return endpoint_type();
+    endpoint.resize(addr_len);
+    return endpoint;
+  }
+
+  // Disable sends or receives on the socket.
+  boost::system::error_code shutdown(base_implementation_type& impl,
+      socket_base::shutdown_type what, boost::system::error_code& ec)
+  {
+    socket_ops::shutdown(impl.socket_, what, ec);
+    return ec;
+  }
+
+  // Send a datagram to the specified endpoint. Returns the number of bytes
+  // sent.
+  template <typename ConstBufferSequence>
+  size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers,
+      const endpoint_type& destination, socket_base::message_flags flags,
+      boost::system::error_code& ec)
+  {
+    typedef buffer_sequence_adapter<boost::asio::const_buffer,
+        ConstBufferSequence> bufs_type;
+
+    if (bufs_type::is_single_buffer)
+    {
+      return socket_ops::sync_sendto1(impl.socket_, impl.state_,
+          bufs_type::first(buffers).data(),
+          bufs_type::first(buffers).size(), flags,
+          destination.data(), destination.size(), ec);
+    }
+    else
+    {
+      bufs_type bufs(buffers);
+      return socket_ops::sync_sendto(impl.socket_, impl.state_,
+          bufs.buffers(), bufs.count(), flags,
+          destination.data(), destination.size(), ec);
+    }
+  }
+
+  // Wait until data can be sent without blocking.
+  size_t send_to(implementation_type& impl, const null_buffers&,
+      const endpoint_type&, socket_base::message_flags,
+      boost::system::error_code& ec)
+  {
+    // Wait for socket to become ready.
+    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
+
+    return 0;
+  }
+
+  // Start an asynchronous send. The data being sent must be valid for the
+  // lifetime of the asynchronous operation.
+  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
+  void async_send_to(implementation_type& impl,
+      const ConstBufferSequence& buffers,
+      const endpoint_type& destination, socket_base::message_flags flags,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_socket_sendto_op<ConstBufferSequence,
+        endpoint_type, Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.socket_, impl.state_,
+        buffers, destination, flags, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
+            &impl.io_object_data_, io_uring_service::write_op);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "socket", &impl, impl.socket_, "async_send_to"));
+
+    start_op(impl, io_uring_service::write_op, p.p, is_continuation, false);
+    p.v = p.p = 0;
+  }
+
+  // Start an asynchronous wait until data can be sent without blocking.
+  template <typename Handler, typename IoExecutor>
+  void async_send_to(implementation_type& impl, const null_buffers&,
+      const endpoint_type&, socket_base::message_flags,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.socket_, POLLOUT, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
+            &impl.io_object_data_, io_uring_service::write_op);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_send_to(null_buffers)"));
+
+    start_op(impl, io_uring_service::write_op, p.p, is_continuation, false);
+    p.v = p.p = 0;
+  }
+
+  // Receive a datagram with the endpoint of the sender. Returns the number of
+  // bytes received.
+  template <typename MutableBufferSequence>
+  size_t receive_from(implementation_type& impl,
+      const MutableBufferSequence& buffers,
+      endpoint_type& sender_endpoint, socket_base::message_flags flags,
+      boost::system::error_code& ec)
+  {
+    typedef buffer_sequence_adapter<boost::asio::mutable_buffer,
+        MutableBufferSequence> bufs_type;
+
+    std::size_t addr_len = sender_endpoint.capacity();
+    std::size_t bytes_recvd;
+    if (bufs_type::is_single_buffer)
+    {
+      bytes_recvd = socket_ops::sync_recvfrom1(impl.socket_,
+          impl.state_, bufs_type::first(buffers).data(),
+          bufs_type::first(buffers).size(), flags,
+          sender_endpoint.data(), &addr_len, ec);
+    }
+    else
+    {
+      bufs_type bufs(buffers);
+      bytes_recvd = socket_ops::sync_recvfrom(
+          impl.socket_, impl.state_, bufs.buffers(), bufs.count(),
+          flags, sender_endpoint.data(), &addr_len, ec);
+    }
+
+    if (!ec)
+      sender_endpoint.resize(addr_len);
+
+    return bytes_recvd;
+  }
+
+  // Wait until data can be received without blocking.
+  size_t receive_from(implementation_type& impl, const null_buffers&,
+      endpoint_type& sender_endpoint, socket_base::message_flags,
+      boost::system::error_code& ec)
+  {
+    // Wait for socket to become ready.
+    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
+
+    // Reset endpoint since it can be given no sensible value at this time.
+    sender_endpoint = endpoint_type();
+
+    return 0;
+  }
+
+  // Start an asynchronous receive. The buffer for the data being received and
+  // the sender_endpoint object must both be valid for the lifetime of the
+  // asynchronous operation.
+  template <typename MutableBufferSequence,
+      typename Handler, typename IoExecutor>
+  void async_receive_from(implementation_type& impl,
+      const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
+      socket_base::message_flags flags, Handler& handler,
+      const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    int op_type = (flags & socket_base::message_out_of_band)
+      ? io_uring_service::except_op : io_uring_service::read_op;
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_socket_recvfrom_op<MutableBufferSequence,
+        endpoint_type, Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.socket_, impl.state_,
+        buffers, sender_endpoint, flags, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(
+            &io_uring_service_, &impl.io_object_data_, op_type);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "socket", &impl, impl.socket_, "async_receive_from"));
+
+    start_op(impl, op_type, p.p, is_continuation, false);
+    p.v = p.p = 0;
+  }
+
+  // Wait until data can be received without blocking.
+  template <typename Handler, typename IoExecutor>
+  void async_receive_from(implementation_type& impl, const null_buffers&,
+      endpoint_type& sender_endpoint, socket_base::message_flags flags,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    int op_type;
+    int poll_flags;
+    if ((flags & socket_base::message_out_of_band) != 0)
+    {
+      op_type = io_uring_service::except_op;
+      poll_flags = POLLPRI;
+    }
+    else
+    {
+      op_type = io_uring_service::read_op;
+      poll_flags = POLLIN;
+    }
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.socket_, poll_flags, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(
+            &io_uring_service_, &impl.io_object_data_, op_type);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_receive_from(null_buffers)"));
+
+    // Reset endpoint since it can be given no sensible value at this time.
+    sender_endpoint = endpoint_type();
+
+    start_op(impl, op_type, p.p, is_continuation, false);
+    p.v = p.p = 0;
+  }
+
+  // Accept a new connection.
+  template <typename Socket>
+  boost::system::error_code accept(implementation_type& impl,
+      Socket& peer, endpoint_type* peer_endpoint, boost::system::error_code& ec)
+  {
+    // We cannot accept a socket that is already open.
+    if (peer.is_open())
+    {
+      ec = boost::asio::error::already_open;
+      return ec;
+    }
+
+    std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
+    socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
+          impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
+          peer_endpoint ? &addr_len : 0, ec));
+
+    // On success, assign new connection to peer socket object.
+    if (new_socket.get() != invalid_socket)
+    {
+      if (peer_endpoint)
+        peer_endpoint->resize(addr_len);
+      peer.assign(impl.protocol_, new_socket.get(), ec);
+      if (!ec)
+        new_socket.release();
+    }
+
+    return ec;
+  }
+
+  // Start an asynchronous accept. The peer and peer_endpoint objects must be
+  // valid until the accept's handler is invoked.
+  template <typename Socket, typename Handler, typename IoExecutor>
+  void async_accept(implementation_type& impl, Socket& peer,
+      endpoint_type* peer_endpoint, Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_socket_accept_op<Socket, Protocol, Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.socket_, impl.state_,
+        peer, impl.protocol_, peer_endpoint, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected() && !peer.is_open())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
+            &impl.io_object_data_, io_uring_service::read_op);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "socket", &impl, impl.socket_, "async_accept"));
+
+    start_accept_op(impl, p.p, is_continuation, peer.is_open());
+    p.v = p.p = 0;
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  // Start an asynchronous accept. The peer_endpoint object must be valid until
+  // the accept's handler is invoked.
+  template <typename PeerIoExecutor, typename Handler, typename IoExecutor>
+  void async_move_accept(implementation_type& impl,
+      const PeerIoExecutor& peer_io_ex, endpoint_type* peer_endpoint,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_socket_move_accept_op<Protocol,
+        PeerIoExecutor, Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, peer_io_ex, impl.socket_,
+        impl.state_, impl.protocol_, peer_endpoint, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
+            &impl.io_object_data_, io_uring_service::read_op);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "socket", &impl, impl.socket_, "async_accept"));
+
+    start_accept_op(impl, p.p, is_continuation, false);
+    p.v = p.p = 0;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  // Connect the socket to the specified endpoint.
+  boost::system::error_code connect(implementation_type& impl,
+      const endpoint_type& peer_endpoint, boost::system::error_code& ec)
+  {
+    socket_ops::sync_connect(impl.socket_,
+        peer_endpoint.data(), peer_endpoint.size(), ec);
+    return ec;
+  }
+
+  // Start an asynchronous connect.
+  template <typename Handler, typename IoExecutor>
+  void async_connect(implementation_type& impl,
+      const endpoint_type& peer_endpoint,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_socket_connect_op<Protocol, Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.socket_,
+        peer_endpoint, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
+            &impl.io_object_data_, io_uring_service::write_op);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "socket", &impl, impl.socket_, "async_connect"));
+
+    start_op(impl, io_uring_service::write_op, p.p, is_continuation, false);
+    p.v = p.p = 0;
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_SOCKET_SERVICE_HPP
diff --git a/boost/asio/detail/io_uring_socket_service_base.hpp b/boost/asio/detail/io_uring_socket_service_base.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..40c1fa26ef77e8509ade6875519fb53aea6e1594
--- /dev/null
+++ b/boost/asio/detail/io_uring_socket_service_base.hpp
@@ -0,0 +1,665 @@
+//
+// detail/io_uring_socket_service_base.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_SOCKET_SERVICE_BASE_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_SOCKET_SERVICE_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING)
+
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/cancellation_type.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/socket_base.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/memory.hpp>
+#include <boost/asio/detail/io_uring_null_buffers_op.hpp>
+#include <boost/asio/detail/io_uring_service.hpp>
+#include <boost/asio/detail/io_uring_socket_recv_op.hpp>
+#include <boost/asio/detail/io_uring_socket_recvmsg_op.hpp>
+#include <boost/asio/detail/io_uring_socket_send_op.hpp>
+#include <boost/asio/detail/io_uring_wait_op.hpp>
+#include <boost/asio/detail/socket_holder.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class io_uring_socket_service_base
+{
+public:
+  // The native type of a socket.
+  typedef socket_type native_handle_type;
+
+  // The implementation type of the socket.
+  struct base_implementation_type
+  {
+    // The native socket representation.
+    socket_type socket_;
+
+    // The current state of the socket.
+    socket_ops::state_type state_;
+
+    // Per I/O object data used by the io_uring_service.
+    io_uring_service::per_io_object_data io_object_data_;
+  };
+
+  // Constructor.
+  BOOST_ASIO_DECL io_uring_socket_service_base(execution_context& context);
+
+  // Destroy all user-defined handler objects owned by the service.
+  BOOST_ASIO_DECL void base_shutdown();
+
+  // Construct a new socket implementation.
+  BOOST_ASIO_DECL void construct(base_implementation_type& impl);
+
+  // Move-construct a new socket implementation.
+  BOOST_ASIO_DECL void base_move_construct(base_implementation_type& impl,
+      base_implementation_type& other_impl) BOOST_ASIO_NOEXCEPT;
+
+  // Move-assign from another socket implementation.
+  BOOST_ASIO_DECL void base_move_assign(base_implementation_type& impl,
+      io_uring_socket_service_base& other_service,
+      base_implementation_type& other_impl);
+
+  // Destroy a socket implementation.
+  BOOST_ASIO_DECL void destroy(base_implementation_type& impl);
+
+  // Determine whether the socket is open.
+  bool is_open(const base_implementation_type& impl) const
+  {
+    return impl.socket_ != invalid_socket;
+  }
+
+  // Destroy a socket implementation.
+  BOOST_ASIO_DECL boost::system::error_code close(
+      base_implementation_type& impl, boost::system::error_code& ec);
+
+  // Release ownership of the socket.
+  BOOST_ASIO_DECL socket_type release(
+      base_implementation_type& impl, boost::system::error_code& ec);
+
+  // Get the native socket representation.
+  native_handle_type native_handle(base_implementation_type& impl)
+  {
+    return impl.socket_;
+  }
+
+  // Cancel all operations associated with the socket.
+  BOOST_ASIO_DECL boost::system::error_code cancel(
+      base_implementation_type& impl, boost::system::error_code& ec);
+
+  // Determine whether the socket is at the out-of-band data mark.
+  bool at_mark(const base_implementation_type& impl,
+      boost::system::error_code& ec) const
+  {
+    return socket_ops::sockatmark(impl.socket_, ec);
+  }
+
+  // Determine the number of bytes available for reading.
+  std::size_t available(const base_implementation_type& impl,
+      boost::system::error_code& ec) const
+  {
+    return socket_ops::available(impl.socket_, ec);
+  }
+
+  // Place the socket into the state where it will listen for new connections.
+  boost::system::error_code listen(base_implementation_type& impl,
+      int backlog, boost::system::error_code& ec)
+  {
+    socket_ops::listen(impl.socket_, backlog, ec);
+    return ec;
+  }
+
+  // Perform an IO control command on the socket.
+  template <typename IO_Control_Command>
+  boost::system::error_code io_control(base_implementation_type& impl,
+      IO_Control_Command& command, boost::system::error_code& ec)
+  {
+    socket_ops::ioctl(impl.socket_, impl.state_, command.name(),
+        static_cast<ioctl_arg_type*>(command.data()), ec);
+    return ec;
+  }
+
+  // Gets the non-blocking mode of the socket.
+  bool non_blocking(const base_implementation_type& impl) const
+  {
+    return (impl.state_ & socket_ops::user_set_non_blocking) != 0;
+  }
+
+  // Sets the non-blocking mode of the socket.
+  boost::system::error_code non_blocking(base_implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    socket_ops::set_user_non_blocking(impl.socket_, impl.state_, mode, ec);
+    return ec;
+  }
+
+  // Gets the non-blocking mode of the native socket implementation.
+  bool native_non_blocking(const base_implementation_type& impl) const
+  {
+    return (impl.state_ & socket_ops::internal_non_blocking) != 0;
+  }
+
+  // Sets the non-blocking mode of the native socket implementation.
+  boost::system::error_code native_non_blocking(base_implementation_type& impl,
+      bool mode, boost::system::error_code& ec)
+  {
+    socket_ops::set_internal_non_blocking(impl.socket_, impl.state_, mode, ec);
+    return ec;
+  }
+
+  // Wait for the socket to become ready to read, ready to write, or to have
+  // pending error conditions.
+  boost::system::error_code wait(base_implementation_type& impl,
+      socket_base::wait_type w, boost::system::error_code& ec)
+  {
+    switch (w)
+    {
+    case socket_base::wait_read:
+      socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
+      break;
+    case socket_base::wait_write:
+      socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
+      break;
+    case socket_base::wait_error:
+      socket_ops::poll_error(impl.socket_, impl.state_, -1, ec);
+      break;
+    default:
+      ec = boost::asio::error::invalid_argument;
+      break;
+    }
+
+    return ec;
+  }
+
+  // Asynchronously wait for the socket to become ready to read, ready to
+  // write, or to have pending error conditions.
+  template <typename Handler, typename IoExecutor>
+  void async_wait(base_implementation_type& impl,
+      socket_base::wait_type w, Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    int op_type;
+    int poll_flags;
+    switch (w)
+    {
+    case socket_base::wait_read:
+      op_type = io_uring_service::read_op;
+      poll_flags = POLLIN;
+      break;
+    case socket_base::wait_write:
+      op_type = io_uring_service::write_op;
+      poll_flags = POLLOUT;
+      break;
+    case socket_base::wait_error:
+      op_type = io_uring_service::except_op;
+      poll_flags = POLLPRI | POLLERR | POLLHUP;
+      break;
+    default:
+      op_type = -1;
+      poll_flags = -1;
+      return;
+    }
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_wait_op<Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.socket_,
+        poll_flags, handler, io_ex);
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "socket", &impl, impl.socket_, "async_wait"));
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(
+            &io_uring_service_, &impl.io_object_data_, op_type);
+    }
+
+    start_op(impl, op_type, p.p, is_continuation, op_type == -1);
+    p.v = p.p = 0;
+  }
+
+  // Send the given data to the peer.
+  template <typename ConstBufferSequence>
+  size_t send(base_implementation_type& impl,
+      const ConstBufferSequence& buffers,
+      socket_base::message_flags flags, boost::system::error_code& ec)
+  {
+    typedef buffer_sequence_adapter<boost::asio::const_buffer,
+        ConstBufferSequence> bufs_type;
+
+    if (bufs_type::is_single_buffer)
+    {
+      return socket_ops::sync_send1(impl.socket_,
+          impl.state_, bufs_type::first(buffers).data(),
+          bufs_type::first(buffers).size(), flags, ec);
+    }
+    else
+    {
+      bufs_type bufs(buffers);
+      return socket_ops::sync_send(impl.socket_, impl.state_,
+          bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
+    }
+  }
+
+  // Wait until data can be sent without blocking.
+  size_t send(base_implementation_type& impl, const null_buffers&,
+      socket_base::message_flags, boost::system::error_code& ec)
+  {
+    // Wait for socket to become ready.
+    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
+
+    return 0;
+  }
+
+  // Start an asynchronous send. The data being sent must be valid for the
+  // lifetime of the asynchronous operation.
+  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
+  void async_send(base_implementation_type& impl,
+      const ConstBufferSequence& buffers, socket_base::message_flags flags,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_socket_send_op<
+        ConstBufferSequence, Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.socket_,
+        impl.state_, buffers, flags, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
+            &impl.io_object_data_, io_uring_service::write_op);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "socket", &impl, impl.socket_, "async_send"));
+
+    start_op(impl, io_uring_service::write_op, p.p, is_continuation,
+        ((impl.state_ & socket_ops::stream_oriented)
+          && buffer_sequence_adapter<boost::asio::const_buffer,
+            ConstBufferSequence>::all_empty(buffers)));
+    p.v = p.p = 0;
+  }
+
+  // Start an asynchronous wait until data can be sent without blocking.
+  template <typename Handler, typename IoExecutor>
+  void async_send(base_implementation_type& impl, const null_buffers&,
+      socket_base::message_flags, Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.socket_, POLLOUT, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
+            &impl.io_object_data_, io_uring_service::write_op);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "socket", &impl, impl.socket_, "async_send(null_buffers)"));
+
+    start_op(impl, io_uring_service::write_op, p.p, is_continuation, false);
+    p.v = p.p = 0;
+  }
+
+  // Receive some data from the peer. Returns the number of bytes received.
+  template <typename MutableBufferSequence>
+  size_t receive(base_implementation_type& impl,
+      const MutableBufferSequence& buffers,
+      socket_base::message_flags flags, boost::system::error_code& ec)
+  {
+    typedef buffer_sequence_adapter<boost::asio::mutable_buffer,
+        MutableBufferSequence> bufs_type;
+
+    if (bufs_type::is_single_buffer)
+    {
+      return socket_ops::sync_recv1(impl.socket_,
+          impl.state_, bufs_type::first(buffers).data(),
+          bufs_type::first(buffers).size(), flags, ec);
+    }
+    else
+    {
+      bufs_type bufs(buffers);
+      return socket_ops::sync_recv(impl.socket_, impl.state_,
+          bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
+    }
+  }
+
+  // Wait until data can be received without blocking.
+  size_t receive(base_implementation_type& impl, const null_buffers&,
+      socket_base::message_flags, boost::system::error_code& ec)
+  {
+    // Wait for socket to become ready.
+    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
+
+    return 0;
+  }
+
+  // Start an asynchronous receive. The buffer for the data being received
+  // must be valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence,
+      typename Handler, typename IoExecutor>
+  void async_receive(base_implementation_type& impl,
+      const MutableBufferSequence& buffers, socket_base::message_flags flags,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    int op_type = (flags & socket_base::message_out_of_band)
+      ? io_uring_service::except_op : io_uring_service::read_op;
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_socket_recv_op<
+        MutableBufferSequence, Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.socket_,
+        impl.state_, buffers, flags, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(
+            &io_uring_service_, &impl.io_object_data_, op_type);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "socket", &impl, impl.socket_, "async_receive"));
+
+    start_op(impl, op_type, p.p, is_continuation,
+        ((impl.state_ & socket_ops::stream_oriented)
+          && buffer_sequence_adapter<boost::asio::mutable_buffer,
+            MutableBufferSequence>::all_empty(buffers)));
+    p.v = p.p = 0;
+  }
+
+  // Wait until data can be received without blocking.
+  template <typename Handler, typename IoExecutor>
+  void async_receive(base_implementation_type& impl,
+      const null_buffers&, socket_base::message_flags flags,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    int op_type;
+    int poll_flags;
+    if ((flags & socket_base::message_out_of_band) != 0)
+    {
+      op_type = io_uring_service::except_op;
+      poll_flags = POLLPRI;
+    }
+    else
+    {
+      op_type = io_uring_service::read_op;
+      poll_flags = POLLIN;
+    }
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.socket_, poll_flags, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(
+            &io_uring_service_, &impl.io_object_data_, op_type);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "socket", &impl, impl.socket_, "async_receive(null_buffers)"));
+
+    start_op(impl, op_type, p.p, is_continuation, false);
+    p.v = p.p = 0;
+  }
+
+  // Receive some data with associated flags. Returns the number of bytes
+  // received.
+  template <typename MutableBufferSequence>
+  size_t receive_with_flags(base_implementation_type& impl,
+      const MutableBufferSequence& buffers,
+      socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, boost::system::error_code& ec)
+  {
+    buffer_sequence_adapter<boost::asio::mutable_buffer,
+        MutableBufferSequence> bufs(buffers);
+
+    return socket_ops::sync_recvmsg(impl.socket_, impl.state_,
+        bufs.buffers(), bufs.count(), in_flags, out_flags, ec);
+  }
+
+  // Wait until data can be received without blocking.
+  size_t receive_with_flags(base_implementation_type& impl,
+      const null_buffers&, socket_base::message_flags,
+      socket_base::message_flags& out_flags, boost::system::error_code& ec)
+  {
+    // Wait for socket to become ready.
+    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
+
+    // Clear out_flags, since we cannot give it any other sensible value when
+    // performing a null_buffers operation.
+    out_flags = 0;
+
+    return 0;
+  }
+
+  // Start an asynchronous receive. The buffer for the data being received
+  // must be valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence,
+      typename Handler, typename IoExecutor>
+  void async_receive_with_flags(base_implementation_type& impl,
+      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, Handler& handler,
+      const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    int op_type = (in_flags & socket_base::message_out_of_band)
+      ? io_uring_service::except_op : io_uring_service::read_op;
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_socket_recvmsg_op<
+        MutableBufferSequence, Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.socket_, impl.state_,
+        buffers, in_flags, out_flags, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(
+            &io_uring_service_, &impl.io_object_data_, op_type);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
+          "socket", &impl, impl.socket_, "async_receive_with_flags"));
+
+    start_op(impl, op_type, p.p, is_continuation, false);
+    p.v = p.p = 0;
+  }
+
+  // Wait until data can be received without blocking.
+  template <typename Handler, typename IoExecutor>
+  void async_receive_with_flags(base_implementation_type& impl,
+      const null_buffers&, socket_base::message_flags in_flags,
+      socket_base::message_flags& out_flags, Handler& handler,
+      const IoExecutor& io_ex)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    int op_type;
+    int poll_flags;
+    if ((in_flags & socket_base::message_out_of_band) != 0)
+    {
+      op_type = io_uring_service::except_op;
+      poll_flags = POLLPRI;
+    }
+    else
+    {
+      op_type = io_uring_service::read_op;
+      poll_flags = POLLIN;
+    }
+
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(success_ec_, impl.socket_, poll_flags, handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<io_uring_op_cancellation>(
+            &io_uring_service_, &impl.io_object_data_, op_type);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p, "socket",
+          &impl, impl.socket_, "async_receive_with_flags(null_buffers)"));
+
+    // Clear out_flags, since we cannot give it any other sensible value when
+    // performing a null_buffers operation.
+    out_flags = 0;
+
+    start_op(impl, op_type, p.p, is_continuation, false);
+    p.v = p.p = 0;
+  }
+
+protected:
+  // Open a new socket implementation.
+  BOOST_ASIO_DECL boost::system::error_code do_open(
+      base_implementation_type& impl, int af,
+      int type, int protocol, boost::system::error_code& ec);
+
+  // Assign a native socket to a socket implementation.
+  BOOST_ASIO_DECL boost::system::error_code do_assign(
+      base_implementation_type& impl, int type,
+      const native_handle_type& native_socket, boost::system::error_code& ec);
+
+  // Start the asynchronous read or write operation.
+  BOOST_ASIO_DECL void start_op(base_implementation_type& impl, int op_type,
+      io_uring_operation* op, bool is_continuation, bool noop);
+
+  // Start the asynchronous accept operation.
+  BOOST_ASIO_DECL void start_accept_op(base_implementation_type& impl,
+      io_uring_operation* op, bool is_continuation, bool peer_is_open);
+
+  // Helper class used to implement per-operation cancellation
+  class io_uring_op_cancellation
+  {
+  public:
+    io_uring_op_cancellation(io_uring_service* s,
+        io_uring_service::per_io_object_data* p, int o)
+      : io_uring_service_(s),
+        io_object_data_(p),
+        op_type_(o)
+    {
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+      if (!!(type &
+            (cancellation_type::terminal
+              | cancellation_type::partial
+              | cancellation_type::total)))
+      {
+        io_uring_service_->cancel_ops_by_key(*io_object_data_, op_type_, this);
+      }
+    }
+
+  private:
+    io_uring_service* io_uring_service_;
+    io_uring_service::per_io_object_data* io_object_data_;
+    int op_type_;
+  };
+
+  // The io_uring_service that performs event demultiplexing for the service.
+  io_uring_service& io_uring_service_;
+
+  // Cached success value to avoid accessing category singleton.
+  const boost::system::error_code success_ec_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/detail/impl/io_uring_socket_service_base.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_SOCKET_SERVICE_BASE_HPP
diff --git a/boost/asio/detail/io_uring_wait_op.hpp b/boost/asio/detail/io_uring_wait_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..cbc6951e9188c466d082c47db836f5a8a7e39a04
--- /dev/null
+++ b/boost/asio/detail/io_uring_wait_op.hpp
@@ -0,0 +1,111 @@
+//
+// detail/io_uring_wait_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_URING_WAIT_OP_HPP
+#define BOOST_ASIO_DETAIL_IO_URING_WAIT_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_work.hpp>
+#include <boost/asio/detail/io_uring_operation.hpp>
+#include <boost/asio/detail/memory.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Handler, typename IoExecutor>
+class io_uring_wait_op : public io_uring_operation
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(io_uring_wait_op);
+
+  io_uring_wait_op(const boost::system::error_code& success_ec, int descriptor,
+      int poll_flags, Handler& handler, const IoExecutor& io_ex)
+    : io_uring_operation(success_ec, &io_uring_wait_op::do_prepare,
+        &io_uring_wait_op::do_perform, &io_uring_wait_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex),
+      descriptor_(descriptor),
+      poll_flags_(poll_flags)
+  {
+  }
+
+  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
+  {
+    io_uring_wait_op* o(static_cast<io_uring_wait_op*>(base));
+
+    ::io_uring_prep_poll_add(sqe, o->descriptor_, o->poll_flags_);
+  }
+
+  static bool do_perform(io_uring_operation*, bool after_completion)
+  {
+    return after_completion;
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the handler object.
+    io_uring_wait_op* o(static_cast<io_uring_wait_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder1<Handler, boost::system::error_code>
+      handler(o->handler_, o->ec_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  handler_work<Handler, IoExecutor> work_;
+  int descriptor_;
+  int poll_flags_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_IO_URING_WAIT_OP_HPP
diff --git a/boost/asio/detail/is_buffer_sequence.hpp b/boost/asio/detail/is_buffer_sequence.hpp
index 53d33ad445a0d1d8da29fdc07f1d6bff42d3a297..16c62596f1abba65d4707abedf0076b30b93f255 100644
--- a/boost/asio/detail/is_buffer_sequence.hpp
+++ b/boost/asio/detail/is_buffer_sequence.hpp
@@ -2,7 +2,7 @@
 // detail/is_buffer_sequence.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -25,6 +25,8 @@ namespace asio {
 
 class mutable_buffer;
 class const_buffer;
+class mutable_registered_buffer;
+class const_registered_buffer;
 
 namespace detail {
 
@@ -259,6 +261,30 @@ struct is_buffer_sequence<const_buffer, mutable_buffer>
 {
 };
 
+template <>
+struct is_buffer_sequence<mutable_registered_buffer, mutable_buffer>
+  : true_type
+{
+};
+
+template <>
+struct is_buffer_sequence<mutable_registered_buffer, const_buffer>
+  : true_type
+{
+};
+
+template <>
+struct is_buffer_sequence<const_registered_buffer, const_buffer>
+  : true_type
+{
+};
+
+template <>
+struct is_buffer_sequence<const_registered_buffer, mutable_buffer>
+  : false_type
+{
+};
+
 template <typename T>
 struct is_dynamic_buffer_class_v1
   : integral_constant<bool,
diff --git a/boost/asio/detail/is_executor.hpp b/boost/asio/detail/is_executor.hpp
index abd80dd27f371f272f373b965a23732a69d8a0f6..326480e3d8059cf976f5e8c815c8d6f4830b1bde 100644
--- a/boost/asio/detail/is_executor.hpp
+++ b/boost/asio/detail/is_executor.hpp
@@ -2,7 +2,7 @@
 // detail/is_executor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/keyword_tss_ptr.hpp b/boost/asio/detail/keyword_tss_ptr.hpp
index 68f296c9b1070d678f487dc8bdb9579e0c91dde6..a72e3c09295ca7aec884a6fad9c4a5ed48a72015 100644
--- a/boost/asio/detail/keyword_tss_ptr.hpp
+++ b/boost/asio/detail/keyword_tss_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/keyword_tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/kqueue_reactor.hpp b/boost/asio/detail/kqueue_reactor.hpp
index 0823a5e576197f2d41c3ed64d6cb7ab1fa451930..89f99f98f82bfaab598eb9ec50428cbd5fef60dd 100644
--- a/boost/asio/detail/kqueue_reactor.hpp
+++ b/boost/asio/detail/kqueue_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/kqueue_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2005 Stefan Arentz (stefan at soze dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -24,11 +24,12 @@
 #include <sys/types.h>
 #include <sys/event.h>
 #include <sys/time.h>
+#include <boost/asio/detail/conditionally_enabled_mutex.hpp>
 #include <boost/asio/detail/limits.hpp>
-#include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/object_pool.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
+#include <boost/asio/detail/scheduler_task.hpp>
 #include <boost/asio/detail/select_interrupter.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
@@ -51,7 +52,8 @@ namespace detail {
 class scheduler;
 
 class kqueue_reactor
-  : public execution_context_service_base<kqueue_reactor>
+  : public execution_context_service_base<kqueue_reactor>,
+    public scheduler_task
 {
 private:
   // The mutex type used by this reactor.
@@ -115,10 +117,7 @@ public:
       per_descriptor_data& source_descriptor_data);
 
   // Post a reactor operation for immediate completion.
-  void post_immediate_completion(reactor_op* op, bool is_continuation)
-  {
-    scheduler_.post_immediate_completion(op, is_continuation);
-  }
+  void post_immediate_completion(operation* op, bool is_continuation);
 
   // Start a new operation. The reactor operation will be performed when the
   // given descriptor is flagged as ready, or an error has occurred.
@@ -132,6 +131,13 @@ public:
   BOOST_ASIO_DECL void cancel_ops(socket_type descriptor,
       per_descriptor_data& descriptor_data);
 
+  // Cancel all operations associated with the given descriptor and key. The
+  // handlers associated with the descriptor will be invoked with the
+  // operation_aborted error.
+  BOOST_ASIO_DECL void cancel_ops_by_key(socket_type descriptor,
+      per_descriptor_data& descriptor_data,
+      int op_type, void* cancellation_key);
+
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor. The reactor resources associated with
   // the descriptor must be released by calling cleanup_descriptor_data.
@@ -171,6 +177,12 @@ public:
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Cancel the timer operations associated with the given key.
+  template <typename Time_Traits>
+  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data* timer,
+      void* cancellation_key);
+
   // Move the timer operations associated with the given timer.
   template <typename Time_Traits>
   void move_timer(timer_queue<Time_Traits>& queue,
diff --git a/boost/asio/detail/local_free_on_block_exit.hpp b/boost/asio/detail/local_free_on_block_exit.hpp
index e9e86fe45c6721f227756e6f836339999f5f25bb..073a1c31ca06337d478cb743eca1e54fc2b09824 100644
--- a/boost/asio/detail/local_free_on_block_exit.hpp
+++ b/boost/asio/detail/local_free_on_block_exit.hpp
@@ -2,7 +2,7 @@
 // detail/local_free_on_block_exit.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/macos_fenced_block.hpp b/boost/asio/detail/macos_fenced_block.hpp
index 7dcd267adb9514a4b95ef1bd86975a1de2146abf..42636121e7f0d747a85f615df0ba98bfbbb97d6b 100644
--- a/boost/asio/detail/macos_fenced_block.hpp
+++ b/boost/asio/detail/macos_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/macos_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/memory.hpp b/boost/asio/detail/memory.hpp
index 2d2e3a6f8dc85a3e67e6c4c90094bedde628a0d1..b4b9ad3d7cc460d88e08a5a2e0b7f35d69ed9d7f 100644
--- a/boost/asio/detail/memory.hpp
+++ b/boost/asio/detail/memory.hpp
@@ -2,7 +2,7 @@
 // detail/memory.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,7 +16,11 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <cstddef>
+#include <cstdlib>
 #include <memory>
+#include <new>
+#include <boost/asio/detail/throw_exception.hpp>
 
 #if !defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 # include <boost/make_shared.hpp>
@@ -28,6 +32,14 @@
 # include <boost/utility/addressof.hpp>
 #endif // !defined(BOOST_ASIO_HAS_STD_ADDRESSOF)
 
+#if !defined(BOOST_ASIO_HAS_STD_ALIGNED_ALLOC) \
+  && defined(BOOST_ASIO_HAS_BOOST_ALIGN) \
+  && defined(BOOST_ASIO_HAS_ALIGNOF)
+# include <boost/align/aligned_alloc.hpp>
+#endif // !defined(BOOST_ASIO_HAS_STD_ALIGNED_ALLOC)
+       //   && defined(BOOST_ASIO_HAS_BOOST_ALIGN)
+       //   && defined(BOOST_ASIO_HAS_ALIGNOF)
+
 namespace boost {
 namespace asio {
 namespace detail {
@@ -69,6 +81,57 @@ struct allocator_arg_t {};
   /**/
 #endif // defined(BOOST_ASIO_HAS_CXX11_ALLOCATORS)
 
+inline void* aligned_new(std::size_t align, std::size_t size)
+{
+#if defined(BOOST_ASIO_HAS_STD_ALIGNED_ALLOC) && defined(BOOST_ASIO_HAS_ALIGNOF)
+  align = (align < BOOST_ASIO_DEFAULT_ALIGN) ? BOOST_ASIO_DEFAULT_ALIGN : align;
+  size = (size % align == 0) ? size : size + (align - size % align);
+  void* ptr = std::aligned_alloc(align, size);
+  if (!ptr)
+  {
+    std::bad_alloc ex;
+    boost::asio::detail::throw_exception(ex);
+  }
+  return ptr;
+#elif defined(BOOST_ASIO_HAS_BOOST_ALIGN) && defined(BOOST_ASIO_HAS_ALIGNOF)
+  align = (align < BOOST_ASIO_DEFAULT_ALIGN) ? BOOST_ASIO_DEFAULT_ALIGN : align;
+  size = (size % align == 0) ? size : size + (align - size % align);
+  void* ptr = boost::alignment::aligned_alloc(align, size);
+  if (!ptr)
+  {
+    std::bad_alloc ex;
+    boost::asio::detail::throw_exception(ex);
+  }
+  return ptr;
+#elif defined(BOOST_ASIO_MSVC) && defined(BOOST_ASIO_HAS_ALIGNOF)
+  align = (align < BOOST_ASIO_DEFAULT_ALIGN) ? BOOST_ASIO_DEFAULT_ALIGN : align;
+  size = (size % align == 0) ? size : size + (align - size % align);
+  void* ptr = _aligned_malloc(size, align);
+  if (!ptr)
+  {
+    std::bad_alloc ex;
+    boost::asio::detail::throw_exception(ex);
+  }
+  return ptr;
+#else // defined(BOOST_ASIO_MSVC) && defined(BOOST_ASIO_HAS_ALIGNOF)
+  (void)align;
+  return ::operator new(size);
+#endif // defined(BOOST_ASIO_MSVC) && defined(BOOST_ASIO_HAS_ALIGNOF)
+}
+
+inline void aligned_delete(void* ptr)
+{
+#if defined(BOOST_ASIO_HAS_STD_ALIGNED_ALLOC) && defined(BOOST_ASIO_HAS_ALIGNOF)
+  std::free(ptr);
+#elif defined(BOOST_ASIO_HAS_BOOST_ALIGN) && defined(BOOST_ASIO_HAS_ALIGNOF)
+  boost::alignment::aligned_free(ptr);
+#elif defined(BOOST_ASIO_MSVC) && defined(BOOST_ASIO_HAS_ALIGNOF)
+  _aligned_free(ptr);
+#else // defined(BOOST_ASIO_MSVC) && defined(BOOST_ASIO_HAS_ALIGNOF)
+  ::operator delete(ptr);
+#endif // defined(BOOST_ASIO_MSVC) && defined(BOOST_ASIO_HAS_ALIGNOF)
+}
+
 } // namespace asio
 } // namespace boost
 
diff --git a/boost/asio/detail/mutex.hpp b/boost/asio/detail/mutex.hpp
index c5159dbe8be88567a846c21853aa0c9e2721aa8e..0c5a4dea7b10bdeaabe2b7ebb458763c97e20db1 100644
--- a/boost/asio/detail/mutex.hpp
+++ b/boost/asio/detail/mutex.hpp
@@ -2,7 +2,7 @@
 // detail/mutex.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/non_const_lvalue.hpp b/boost/asio/detail/non_const_lvalue.hpp
index 5dad50ffb4ea51f3cb54cb56c45333feb6f15213..05e2821a13e637d8c0938a6569ff84c4e2663cae 100644
--- a/boost/asio/detail/non_const_lvalue.hpp
+++ b/boost/asio/detail/non_const_lvalue.hpp
@@ -2,7 +2,7 @@
 // detail/non_const_lvalue.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/noncopyable.hpp b/boost/asio/detail/noncopyable.hpp
index df955009567213221318c4c4bf3b1e67bf7d5ef4..d08d779e0c4823584f5ff08d86c22baf9bde7d87 100644
--- a/boost/asio/detail/noncopyable.hpp
+++ b/boost/asio/detail/noncopyable.hpp
@@ -2,7 +2,7 @@
 // detail/noncopyable.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/null_event.hpp b/boost/asio/detail/null_event.hpp
index 131fb3c9afeca01617d5db58dfe9faa784babc63..4f9d4c7845ee4105171d48f70117364f1a7945e9 100644
--- a/boost/asio/detail/null_event.hpp
+++ b/boost/asio/detail/null_event.hpp
@@ -2,7 +2,7 @@
 // detail/null_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/null_fenced_block.hpp b/boost/asio/detail/null_fenced_block.hpp
index 6406bdcd452e696d5e7e61efc6412831bbc817ea..1f8cf227f21292e9158b711d09bbc0fc30d92d92 100644
--- a/boost/asio/detail/null_fenced_block.hpp
+++ b/boost/asio/detail/null_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/null_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/null_global.hpp b/boost/asio/detail/null_global.hpp
index 6a38b52865e69ab218b2d095e654df9da1e2fc5d..686390382cfc7bd7f4095c85cbaed9f6ef570839 100644
--- a/boost/asio/detail/null_global.hpp
+++ b/boost/asio/detail/null_global.hpp
@@ -2,7 +2,7 @@
 // detail/null_global.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/null_mutex.hpp b/boost/asio/detail/null_mutex.hpp
index 81a5d27fa8257734335bf87e3760ed74c9391293..4517c510500064133693c52a12bc40f1b92b6cb4 100644
--- a/boost/asio/detail/null_mutex.hpp
+++ b/boost/asio/detail/null_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/null_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,8 +17,6 @@
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_ASIO_HAS_THREADS)
-
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/scoped_lock.hpp>
 
@@ -61,6 +59,4 @@ public:
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_ASIO_HAS_THREADS)
-
 #endif // BOOST_ASIO_DETAIL_NULL_MUTEX_HPP
diff --git a/boost/asio/detail/null_reactor.hpp b/boost/asio/detail/null_reactor.hpp
index 0511731b56e2594f3742eb10c8ea9f0dcf9eec4c..7af42b29594e99bc2b347dddb9ebdf46bf019855 100644
--- a/boost/asio/detail/null_reactor.hpp
+++ b/boost/asio/detail/null_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/null_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,9 +17,12 @@
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_ASIO_HAS_IOCP) || defined(BOOST_ASIO_WINDOWS_RUNTIME)
+#if defined(BOOST_ASIO_HAS_IOCP) \
+  || defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  || defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
 #include <boost/asio/detail/scheduler_operation.hpp>
+#include <boost/asio/detail/scheduler_task.hpp>
 #include <boost/asio/execution_context.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -29,9 +32,14 @@ namespace asio {
 namespace detail {
 
 class null_reactor
-  : public execution_context_service_base<null_reactor>
+  : public execution_context_service_base<null_reactor>,
+    public scheduler_task
 {
 public:
+  struct per_descriptor_data
+  {
+  };
+
   // Constructor.
   null_reactor(boost::asio::execution_context& ctx)
     : execution_context_service_base<null_reactor>(ctx)
@@ -43,6 +51,11 @@ public:
   {
   }
 
+  // Initialise the task.
+  void init_task()
+  {
+  }
+
   // Destroy all user-defined handler objects owned by the service.
   void shutdown()
   {
@@ -65,6 +78,8 @@ public:
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_ASIO_HAS_IOCP) || defined(BOOST_ASIO_WINDOWS_RUNTIME)
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+       //   || defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   || defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
 #endif // BOOST_ASIO_DETAIL_NULL_REACTOR_HPP
diff --git a/boost/asio/detail/null_signal_blocker.hpp b/boost/asio/detail/null_signal_blocker.hpp
index 561ad6cf9817d2d6fbd575377f6cd7b8202bc580..cf0fc1c931c341aea12b28815d20ddb1de2032e0 100644
--- a/boost/asio/detail/null_signal_blocker.hpp
+++ b/boost/asio/detail/null_signal_blocker.hpp
@@ -2,7 +2,7 @@
 // detail/null_signal_blocker.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/null_socket_service.hpp b/boost/asio/detail/null_socket_service.hpp
index 545a99cc232c0e773a5fad07206ab90a3abb0e72..f43ddf949c8725310ba5ba4e6448b0a39bf8ee6f 100644
--- a/boost/asio/detail/null_socket_service.hpp
+++ b/boost/asio/detail/null_socket_service.hpp
@@ -2,7 +2,7 @@
 // detail/null_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/null_static_mutex.hpp b/boost/asio/detail/null_static_mutex.hpp
index 9ebac46aea64d658a645f7cba6e3008fab72fbc0..ab7206a7280a76312fbe22fbf28dbb9af2f3e2c2 100644
--- a/boost/asio/detail/null_static_mutex.hpp
+++ b/boost/asio/detail/null_static_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/null_static_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/null_thread.hpp b/boost/asio/detail/null_thread.hpp
index d0695516b3af23f23bdb079681cb7a17802caf5c..d9759dd416edc5595b822fbfc7d29739c3c419be 100644
--- a/boost/asio/detail/null_thread.hpp
+++ b/boost/asio/detail/null_thread.hpp
@@ -2,7 +2,7 @@
 // detail/null_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/null_tss_ptr.hpp b/boost/asio/detail/null_tss_ptr.hpp
index f2980c882da8cd7b2d727ad694e256355772f23a..f31d192fa9853deb1318f96973d9221b2474f463 100644
--- a/boost/asio/detail/null_tss_ptr.hpp
+++ b/boost/asio/detail/null_tss_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/null_tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/object_pool.hpp b/boost/asio/detail/object_pool.hpp
index 1ee2b7379b634eaf139b479fcb1aa70414e154cd..9573f9595f80259294de507f8895b6f8fc209f3e 100644
--- a/boost/asio/detail/object_pool.hpp
+++ b/boost/asio/detail/object_pool.hpp
@@ -2,7 +2,7 @@
 // detail/object_pool.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/old_win_sdk_compat.hpp b/boost/asio/detail/old_win_sdk_compat.hpp
index 7c9019cbf1af401c1a4f66528ecf948bb8b93005..780570020ac6a017f5e0de77f96f219f02bfda83 100644
--- a/boost/asio/detail/old_win_sdk_compat.hpp
+++ b/boost/asio/detail/old_win_sdk_compat.hpp
@@ -2,7 +2,7 @@
 // detail/old_win_sdk_compat.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/op_queue.hpp b/boost/asio/detail/op_queue.hpp
index 1b1557d571b73111f83f34a251f8d278cf7db303..c946032658edf2d8c8e67027d82cf52325981911 100644
--- a/boost/asio/detail/op_queue.hpp
+++ b/boost/asio/detail/op_queue.hpp
@@ -2,7 +2,7 @@
 // detail/op_queue.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/operation.hpp b/boost/asio/detail/operation.hpp
index 40eff5114393bd7865ca24acec3bc56a32942d2b..d52afc5fcdf3d26bba165fa7045e7e21eb69fcff 100644
--- a/boost/asio/detail/operation.hpp
+++ b/boost/asio/detail/operation.hpp
@@ -2,7 +2,7 @@
 // detail/operation.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/pipe_select_interrupter.hpp b/boost/asio/detail/pipe_select_interrupter.hpp
index d1420b72713184c40a32b66e4bf0a24946b3701e..4360dacbd04c89ba108ff709b53ff6ba40494564 100644
--- a/boost/asio/detail/pipe_select_interrupter.hpp
+++ b/boost/asio/detail/pipe_select_interrupter.hpp
@@ -2,7 +2,7 @@
 // detail/pipe_select_interrupter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/pop_options.hpp b/boost/asio/detail/pop_options.hpp
index 5192967b76caf7614fd95b368d0aaf47bbaf58ff..c9f00dd1b20bbc47eef87c85e2fb30df683c882c 100644
--- a/boost/asio/detail/pop_options.hpp
+++ b/boost/asio/detail/pop_options.hpp
@@ -2,7 +2,7 @@
 // detail/pop_options.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -51,6 +51,10 @@
 
 # pragma GCC diagnostic pop
 
+# pragma pop_macro ("emit")
+# pragma pop_macro ("signal")
+# pragma pop_macro ("slot")
+
 #elif defined(__GNUC__)
 
 // GNU C++
@@ -77,6 +81,10 @@
 
 # pragma GCC diagnostic pop
 
+# pragma pop_macro ("emit")
+# pragma pop_macro ("signal")
+# pragma pop_macro ("slot")
+
 #elif defined(__KCC)
 
 // Kai C++
@@ -138,4 +146,8 @@
 #  endif
 # endif
 
+# pragma pop_macro ("emit")
+# pragma pop_macro ("signal")
+# pragma pop_macro ("slot")
+
 #endif
diff --git a/boost/asio/detail/posix_event.hpp b/boost/asio/detail/posix_event.hpp
index c153643f928a34f14b73b6b15b9b5a8d2a58e63c..a832dc5212af8cc825b4b1313221da0df5f58ec4 100644
--- a/boost/asio/detail/posix_event.hpp
+++ b/boost/asio/detail/posix_event.hpp
@@ -2,7 +2,7 @@
 // detail/posix_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/posix_fd_set_adapter.hpp b/boost/asio/detail/posix_fd_set_adapter.hpp
index 89302ab6894206538089767fda53358ecc98dad7..7d3151594d663218de34474fa76ccc9e1b6f9dca 100644
--- a/boost/asio/detail/posix_fd_set_adapter.hpp
+++ b/boost/asio/detail/posix_fd_set_adapter.hpp
@@ -2,7 +2,7 @@
 // detail/posix_fd_set_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/posix_global.hpp b/boost/asio/detail/posix_global.hpp
index a9ac379d7ba54ff6bf9ff7986e790dff64c9042b..9ac9f4895e4f1ed418b1bc6af89f14981b95cbaf 100644
--- a/boost/asio/detail/posix_global.hpp
+++ b/boost/asio/detail/posix_global.hpp
@@ -2,7 +2,7 @@
 // detail/posix_global.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/posix_mutex.hpp b/boost/asio/detail/posix_mutex.hpp
index be66370063607f34cb266ee8a43a677f055f5688..ad0354acfe2fc0be7dcb822983cdccb37c608b59 100644
--- a/boost/asio/detail/posix_mutex.hpp
+++ b/boost/asio/detail/posix_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/posix_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/posix_serial_port_service.hpp b/boost/asio/detail/posix_serial_port_service.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f0a2a02f32d169b80560b15d09017e7a6d0c3e0b
--- /dev/null
+++ b/boost/asio/detail/posix_serial_port_service.hpp
@@ -0,0 +1,250 @@
+//
+// detail/posix_serial_port_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_POSIX_SERIAL_PORT_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_POSIX_SERIAL_PORT_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_SERIAL_PORT)
+#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
+
+#include <string>
+#include <boost/asio/error.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/serial_port_base.hpp>
+#include <boost/asio/detail/descriptor_ops.hpp>
+
+#if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/io_uring_descriptor_service.hpp>
+#else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/reactive_descriptor_service.hpp>
+#endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Extend a descriptor_service to provide serial port support.
+class posix_serial_port_service :
+  public execution_context_service_base<posix_serial_port_service>
+{
+public:
+#if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  typedef io_uring_descriptor_service descriptor_service;
+#else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  typedef reactive_descriptor_service descriptor_service;
+#endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+
+  // The native type of a serial port.
+  typedef descriptor_service::native_handle_type native_handle_type;
+
+  // The implementation type of the serial port.
+  typedef descriptor_service::implementation_type implementation_type;
+
+  BOOST_ASIO_DECL posix_serial_port_service(execution_context& context);
+
+  // Destroy all user-defined handler objects owned by the service.
+  BOOST_ASIO_DECL void shutdown();
+
+  // Construct a new serial port implementation.
+  void construct(implementation_type& impl)
+  {
+    descriptor_service_.construct(impl);
+  }
+
+  // Move-construct a new serial port implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    descriptor_service_.move_construct(impl, other_impl);
+  }
+
+  // Move-assign from another serial port implementation.
+  void move_assign(implementation_type& impl,
+      posix_serial_port_service& other_service,
+      implementation_type& other_impl)
+  {
+    descriptor_service_.move_assign(impl,
+        other_service.descriptor_service_, other_impl);
+  }
+
+  // Destroy a serial port implementation.
+  void destroy(implementation_type& impl)
+  {
+    descriptor_service_.destroy(impl);
+  }
+
+  // Open the serial port using the specified device name.
+  BOOST_ASIO_DECL boost::system::error_code open(implementation_type& impl,
+      const std::string& device, boost::system::error_code& ec);
+
+  // Assign a native descriptor to a serial port implementation.
+  boost::system::error_code assign(implementation_type& impl,
+      const native_handle_type& native_descriptor,
+      boost::system::error_code& ec)
+  {
+    return descriptor_service_.assign(impl, native_descriptor, ec);
+  }
+
+  // Determine whether the serial port is open.
+  bool is_open(const implementation_type& impl) const
+  {
+    return descriptor_service_.is_open(impl);
+  }
+
+  // Destroy a serial port implementation.
+  boost::system::error_code close(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    return descriptor_service_.close(impl, ec);
+  }
+
+  // Get the native serial port representation.
+  native_handle_type native_handle(implementation_type& impl)
+  {
+    return descriptor_service_.native_handle(impl);
+  }
+
+  // Cancel all operations associated with the serial port.
+  boost::system::error_code cancel(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    return descriptor_service_.cancel(impl, ec);
+  }
+
+  // Set an option on the serial port.
+  template <typename SettableSerialPortOption>
+  boost::system::error_code set_option(implementation_type& impl,
+      const SettableSerialPortOption& option, boost::system::error_code& ec)
+  {
+    return do_set_option(impl,
+        &posix_serial_port_service::store_option<SettableSerialPortOption>,
+        &option, ec);
+  }
+
+  // Get an option from the serial port.
+  template <typename GettableSerialPortOption>
+  boost::system::error_code get_option(const implementation_type& impl,
+      GettableSerialPortOption& option, boost::system::error_code& ec) const
+  {
+    return do_get_option(impl,
+        &posix_serial_port_service::load_option<GettableSerialPortOption>,
+        &option, ec);
+  }
+
+  // Send a break sequence to the serial port.
+  boost::system::error_code send_break(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    int result = ::tcsendbreak(descriptor_service_.native_handle(impl), 0);
+    descriptor_ops::get_last_error(ec, result < 0);
+    return ec;
+  }
+
+  // Write the given data. Returns the number of bytes sent.
+  template <typename ConstBufferSequence>
+  size_t write_some(implementation_type& impl,
+      const ConstBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    return descriptor_service_.write_some(impl, buffers, ec);
+  }
+
+  // Start an asynchronous write. The data being written must be valid for the
+  // lifetime of the asynchronous operation.
+  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
+  void async_write_some(implementation_type& impl,
+      const ConstBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    descriptor_service_.async_write_some(impl, buffers, handler, io_ex);
+  }
+
+  // Read some data. Returns the number of bytes received.
+  template <typename MutableBufferSequence>
+  size_t read_some(implementation_type& impl,
+      const MutableBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    return descriptor_service_.read_some(impl, buffers, ec);
+  }
+
+  // Start an asynchronous read. The buffer for the data being received must be
+  // valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence,
+      typename Handler, typename IoExecutor>
+  void async_read_some(implementation_type& impl,
+      const MutableBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    descriptor_service_.async_read_some(impl, buffers, handler, io_ex);
+  }
+
+private:
+  // Function pointer type for storing a serial port option.
+  typedef boost::system::error_code (*store_function_type)(
+      const void*, termios&, boost::system::error_code&);
+
+  // Helper function template to store a serial port option.
+  template <typename SettableSerialPortOption>
+  static boost::system::error_code store_option(const void* option,
+      termios& storage, boost::system::error_code& ec)
+  {
+    static_cast<const SettableSerialPortOption*>(option)->store(storage, ec);
+    return ec;
+  }
+
+  // Helper function to set a serial port option.
+  BOOST_ASIO_DECL boost::system::error_code do_set_option(
+      implementation_type& impl, store_function_type store,
+      const void* option, boost::system::error_code& ec);
+
+  // Function pointer type for loading a serial port option.
+  typedef boost::system::error_code (*load_function_type)(
+      void*, const termios&, boost::system::error_code&);
+
+  // Helper function template to load a serial port option.
+  template <typename GettableSerialPortOption>
+  static boost::system::error_code load_option(void* option,
+      const termios& storage, boost::system::error_code& ec)
+  {
+    static_cast<GettableSerialPortOption*>(option)->load(storage, ec);
+    return ec;
+  }
+
+  // Helper function to get a serial port option.
+  BOOST_ASIO_DECL boost::system::error_code do_get_option(
+      const implementation_type& impl, load_function_type load,
+      void* option, boost::system::error_code& ec) const;
+
+  // The implementation used for initiating asynchronous operations.
+  descriptor_service descriptor_service_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/detail/impl/posix_serial_port_service.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_HAS_SERIAL_PORT)
+
+#endif // BOOST_ASIO_DETAIL_POSIX_SERIAL_PORT_SERVICE_HPP
diff --git a/boost/asio/detail/posix_signal_blocker.hpp b/boost/asio/detail/posix_signal_blocker.hpp
index abd126e01e5452e896b54c103e7f4f3d26c3a2c7..62173c4c37f9869f242a72c5424765b8840d0ba8 100644
--- a/boost/asio/detail/posix_signal_blocker.hpp
+++ b/boost/asio/detail/posix_signal_blocker.hpp
@@ -2,7 +2,7 @@
 // detail/posix_signal_blocker.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/posix_static_mutex.hpp b/boost/asio/detail/posix_static_mutex.hpp
index d2d1187445ec892bfcff2ce49b9b78a26ff81278..2faf5f22d359ec805db43cfec8787a7f54951294 100644
--- a/boost/asio/detail/posix_static_mutex.hpp
+++ b/boost/asio/detail/posix_static_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/posix_static_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/posix_thread.hpp b/boost/asio/detail/posix_thread.hpp
index 8b52c8a38ac8c673c42e1bce1e8cb9872b4d899b..23c5b6e7f1aaeea6e84a1a4488f4e8fba605e489 100644
--- a/boost/asio/detail/posix_thread.hpp
+++ b/boost/asio/detail/posix_thread.hpp
@@ -2,7 +2,7 @@
 // detail/posix_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/posix_tss_ptr.hpp b/boost/asio/detail/posix_tss_ptr.hpp
index f014bfba76439e3bacd4bd017fd3efc8ffa78f46..224bef78cb19d4f0b7de3a07a5b826cff7fd41bc 100644
--- a/boost/asio/detail/posix_tss_ptr.hpp
+++ b/boost/asio/detail/posix_tss_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/posix_tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/push_options.hpp b/boost/asio/detail/push_options.hpp
index d658413223fcccf96b6aa4f037e09b2b7ce24da1..1ecccdce8f1f91d57feac87f827d41e33b875888 100644
--- a/boost/asio/detail/push_options.hpp
+++ b/boost/asio/detail/push_options.hpp
@@ -2,7 +2,7 @@
 // detail/push_options.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -57,6 +57,15 @@
 #  pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
 # endif // (__clang_major__ >= 6)
 
+# pragma push_macro ("emit")
+# undef emit
+
+# pragma push_macro ("signal")
+# undef signal
+
+# pragma push_macro ("slot")
+# undef slot
+
 #elif defined(__GNUC__)
 
 // GNU C++
@@ -92,6 +101,15 @@
 #  pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
 # endif // (__GNUC__ >= 7)
 
+# pragma push_macro ("emit")
+# undef emit
+
+# pragma push_macro ("signal")
+# undef signal
+
+# pragma push_macro ("slot")
+# undef slot
+
 #elif defined(__KCC)
 
 // Kai C++
@@ -151,6 +169,7 @@
 # pragma warning (disable:4127)
 # pragma warning (disable:4180)
 # pragma warning (disable:4244)
+# pragma warning (disable:4265)
 # pragma warning (disable:4355)
 # pragma warning (disable:4510)
 # pragma warning (disable:4512)
@@ -188,4 +207,13 @@
 #  endif
 # endif
 
+# pragma push_macro ("emit")
+# undef emit
+
+# pragma push_macro ("signal")
+# undef signal
+
+# pragma push_macro ("slot")
+# undef slot
+
 #endif
diff --git a/boost/asio/detail/reactive_descriptor_service.hpp b/boost/asio/detail/reactive_descriptor_service.hpp
index b6cf08a7835d5d879a55ca0b9b4d083fd4c3a592..ed06a6924c1294588ebd87a6e0453d59977f1902 100644
--- a/boost/asio/detail/reactive_descriptor_service.hpp
+++ b/boost/asio/detail/reactive_descriptor_service.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_descriptor_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,9 +19,12 @@
 
 #if !defined(BOOST_ASIO_WINDOWS) \
   && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
+  && !defined(__CYGWIN__) \
+  && !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
+#include <boost/asio/associated_cancellation_slot.hpp>
 #include <boost/asio/buffer.hpp>
+#include <boost/asio/cancellation_type.hpp>
 #include <boost/asio/execution_context.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
@@ -198,6 +201,9 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_wait_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
@@ -226,6 +232,14 @@ public:
         return;
     }
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.descriptor_, op_type);
+    }
+
     start_op(impl, op_type, p.p, is_continuation, false, false);
     p.v = p.p = 0;
   }
@@ -273,12 +287,24 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef descriptor_write_op<ConstBufferSequence, Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(success_ec_, impl.descriptor_, buffers, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_,
+            impl.descriptor_, reactor::write_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
           &impl, impl.descriptor_, "async_write_some"));
 
@@ -296,12 +322,24 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(success_ec_, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_,
+            impl.descriptor_, reactor::write_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
           &impl, impl.descriptor_, "async_write_some(null_buffers)"));
 
@@ -353,12 +391,24 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef descriptor_read_op<MutableBufferSequence, Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(success_ec_, impl.descriptor_, buffers, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_,
+            impl.descriptor_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
           &impl, impl.descriptor_, "async_read_some"));
 
@@ -376,12 +426,24 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(success_ec_, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_,
+            impl.descriptor_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
           &impl, impl.descriptor_, "async_read_some(null_buffers)"));
 
@@ -394,6 +456,38 @@ private:
   BOOST_ASIO_DECL void start_op(implementation_type& impl, int op_type,
       reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);
 
+  // Helper class used to implement per-operation cancellation
+  class reactor_op_cancellation
+  {
+  public:
+    reactor_op_cancellation(reactor* r,
+        reactor::per_descriptor_data* p, int d, int o)
+      : reactor_(r),
+        reactor_data_(p),
+        descriptor_(d),
+        op_type_(o)
+    {
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+      if (!!(type &
+            (cancellation_type::terminal
+              | cancellation_type::partial
+              | cancellation_type::total)))
+      {
+        reactor_->cancel_ops_by_key(descriptor_,
+            *reactor_data_, op_type_, this);
+      }
+    }
+
+  private:
+    reactor* reactor_;
+    reactor::per_descriptor_data* reactor_data_;
+    int descriptor_;
+    int op_type_;
+  };
+
   // The selector that performs event demultiplexing for the service.
   reactor& reactor_;
 
@@ -414,5 +508,6 @@ private:
 #endif // !defined(BOOST_ASIO_WINDOWS)
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
        //   && !defined(__CYGWIN__)
+       //   && !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
 #endif // BOOST_ASIO_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP
diff --git a/boost/asio/detail/reactive_null_buffers_op.hpp b/boost/asio/detail/reactive_null_buffers_op.hpp
index d591acbfa3256587b076807d4d3e4e0d30929970..b39eed530ebeca670ed75270e390a9028c83e6a8 100644
--- a/boost/asio/detail/reactive_null_buffers_op.hpp
+++ b/boost/asio/detail/reactive_null_buffers_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_null_buffers_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/reactive_socket_accept_op.hpp b/boost/asio/detail/reactive_socket_accept_op.hpp
index e60111c28812715d20c1d5c1e195c8d24655c565..a2ed605611b870268070ed7401922e4d76fa6ee0 100644
--- a/boost/asio/detail/reactive_socket_accept_op.hpp
+++ b/boost/asio/detail/reactive_socket_accept_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_accept_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/reactive_socket_connect_op.hpp b/boost/asio/detail/reactive_socket_connect_op.hpp
index 36a48a1d90ac23fb9d3fc29bc9609e0c231893c5..368dd82177de7bb5874e6a8a54dc9b3b81785bff 100644
--- a/boost/asio/detail/reactive_socket_connect_op.hpp
+++ b/boost/asio/detail/reactive_socket_connect_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_connect_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/reactive_socket_recv_op.hpp b/boost/asio/detail/reactive_socket_recv_op.hpp
index afee8ab5aefa2ddb949de6f7f9f8090043d53efc..e86658a409821c3b8e3fa89a7c3e961202ea4538 100644
--- a/boost/asio/detail/reactive_socket_recv_op.hpp
+++ b/boost/asio/detail/reactive_socket_recv_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_recv_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/reactive_socket_recvfrom_op.hpp b/boost/asio/detail/reactive_socket_recvfrom_op.hpp
index 41d57e720626f000544ee87b24c57c68dcf100c2..5ae79076b527aadce83d1041bc30c5e2f6f189c6 100644
--- a/boost/asio/detail/reactive_socket_recvfrom_op.hpp
+++ b/boost/asio/detail/reactive_socket_recvfrom_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_recvfrom_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/reactive_socket_recvmsg_op.hpp b/boost/asio/detail/reactive_socket_recvmsg_op.hpp
index 798feda7b1a3c3e89132dad15b3f7bdb20c3c141..fbe0054a51c5287f97164793ab34199da0ae94b8 100644
--- a/boost/asio/detail/reactive_socket_recvmsg_op.hpp
+++ b/boost/asio/detail/reactive_socket_recvmsg_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_recvmsg_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/reactive_socket_send_op.hpp b/boost/asio/detail/reactive_socket_send_op.hpp
index 03ff0e88e530bbf177b31a2165c6b96b658b8346..b461045f475748343df4555386ed3401fcb18431 100644
--- a/boost/asio/detail/reactive_socket_send_op.hpp
+++ b/boost/asio/detail/reactive_socket_send_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_send_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/reactive_socket_sendto_op.hpp b/boost/asio/detail/reactive_socket_sendto_op.hpp
index f6e8b33b866408333cc18bba918522458f4859b4..c0c377a0422e03bd86483cf1952648f121c6a9bb 100644
--- a/boost/asio/detail/reactive_socket_sendto_op.hpp
+++ b/boost/asio/detail/reactive_socket_sendto_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_sendto_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/reactive_socket_service.hpp b/boost/asio/detail/reactive_socket_service.hpp
index 6f030f00a94dfde8fc275d5bf08fbca09dde7ec1..0552e571e2cb2adae0f7e92b66476e6701a992ac 100644
--- a/boost/asio/detail/reactive_socket_service.hpp
+++ b/boost/asio/detail/reactive_socket_service.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,7 +17,8 @@
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_ASIO_HAS_IOCP)
+#if !defined(BOOST_ASIO_HAS_IOCP) \
+  && !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/error.hpp>
@@ -261,6 +262,9 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_sendto_op<ConstBufferSequence,
         endpoint_type, Handler, IoExecutor> op;
@@ -269,6 +273,14 @@ public:
     p.p = new (p.v) op(success_ec_, impl.socket_,
         buffers, destination, flags, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::write_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_send_to"));
 
@@ -285,12 +297,23 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(success_ec_, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::write_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_send_to(null_buffers)"));
 
@@ -359,6 +382,9 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_recvfrom_op<MutableBufferSequence,
         endpoint_type, Handler, IoExecutor> op;
@@ -368,6 +394,14 @@ public:
     p.p = new (p.v) op(success_ec_, impl.socket_, protocol,
         buffers, sender_endpoint, flags, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_receive_from"));
 
@@ -387,12 +421,23 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(success_ec_, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_receive_from(null_buffers)"));
 
@@ -445,6 +490,9 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_accept_op<Socket, Protocol, Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
@@ -452,6 +500,14 @@ public:
     p.p = new (p.v) op(success_ec_, impl.socket_, impl.state_,
         peer, impl.protocol_, peer_endpoint, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected() && !peer.is_open())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_accept"));
 
@@ -470,6 +526,9 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_move_accept_op<Protocol,
         PeerIoExecutor, Handler, IoExecutor> op;
@@ -478,6 +537,14 @@ public:
     p.p = new (p.v) op(success_ec_, peer_io_ex, impl.socket_,
         impl.state_, impl.protocol_, peer_endpoint, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_accept"));
 
@@ -504,12 +571,23 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_connect_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(success_ec_, impl.socket_, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::connect_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_connect"));
 
@@ -526,5 +604,6 @@ public:
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // !defined(BOOST_ASIO_HAS_IOCP)
+       //   && !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
 #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP
diff --git a/boost/asio/detail/reactive_socket_service_base.hpp b/boost/asio/detail/reactive_socket_service_base.hpp
index fbe5dc390ec1d0772b0cd5a0536e9e39d35cfa2a..a17ded02ca00a312884703037019ea42c1195ac3 100644
--- a/boost/asio/detail/reactive_socket_service_base.hpp
+++ b/boost/asio/detail/reactive_socket_service_base.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_socket_service_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,9 +18,12 @@
 #include <boost/asio/detail/config.hpp>
 
 #if !defined(BOOST_ASIO_HAS_IOCP) \
-  && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
+#include <boost/asio/associated_cancellation_slot.hpp>
 #include <boost/asio/buffer.hpp>
+#include <boost/asio/cancellation_type.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/execution_context.hpp>
 #include <boost/asio/socket_base.hpp>
@@ -200,6 +203,9 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_wait_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
@@ -228,6 +234,14 @@ public:
         return;
     }
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, op_type);
+    }
+
     start_op(impl, op_type, p.p, is_continuation, false, false);
     p.v = p.p = 0;
   }
@@ -275,6 +289,9 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_send_op<
         ConstBufferSequence, Handler, IoExecutor> op;
@@ -283,6 +300,14 @@ public:
     p.p = new (p.v) op(success_ec_, impl.socket_,
         impl.state_, buffers, flags, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::write_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_send"));
 
@@ -301,12 +326,23 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(success_ec_, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::write_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_send(null_buffers)"));
 
@@ -358,6 +394,9 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_recv_op<
         MutableBufferSequence, Handler, IoExecutor> op;
@@ -366,6 +405,14 @@ public:
     p.p = new (p.v) op(success_ec_, impl.socket_,
         impl.state_, buffers, flags, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_receive"));
 
@@ -389,12 +436,23 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(success_ec_, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_receive(null_buffers)"));
 
@@ -447,6 +505,9 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_recvmsg_op<
         MutableBufferSequence, Handler, IoExecutor> op;
@@ -455,6 +516,14 @@ public:
     p.p = new (p.v) op(success_ec_, impl.socket_,
         buffers, in_flags, out_flags, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_receive_with_flags"));
 
@@ -476,12 +545,23 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(success_ec_, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_receive_with_flags(null_buffers)"));
 
@@ -520,6 +600,38 @@ protected:
       reactor_op* op, bool is_continuation,
       const socket_addr_type* addr, size_t addrlen);
 
+  // Helper class used to implement per-operation cancellation
+  class reactor_op_cancellation
+  {
+  public:
+    reactor_op_cancellation(reactor* r,
+        reactor::per_descriptor_data* p, int d, int o)
+      : reactor_(r),
+        reactor_data_(p),
+        descriptor_(d),
+        op_type_(o)
+    {
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+      if (!!(type &
+            (cancellation_type::terminal
+              | cancellation_type::partial
+              | cancellation_type::total)))
+      {
+        reactor_->cancel_ops_by_key(descriptor_,
+            *reactor_data_, op_type_, this);
+      }
+    }
+
+  private:
+    reactor* reactor_;
+    reactor::per_descriptor_data* reactor_data_;
+    int descriptor_;
+    int op_type_;
+  };
+
   // The selector that performs event demultiplexing for the service.
   reactor& reactor_;
 
@@ -539,5 +651,6 @@ protected:
 
 #endif // !defined(BOOST_ASIO_HAS_IOCP)
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
 #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP
diff --git a/boost/asio/detail/reactive_wait_op.hpp b/boost/asio/detail/reactive_wait_op.hpp
index b9fdace49db5b5c240577919511bf2753ac47aed..c97ab308dd152ee3a8177c27b58915c12294f3d2 100644
--- a/boost/asio/detail/reactive_wait_op.hpp
+++ b/boost/asio/detail/reactive_wait_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactive_wait_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/reactor.hpp b/boost/asio/detail/reactor.hpp
index b6bc3c245c85e5da7bee39fd1a2d38736a32f4a7..705ab9cd3f5768fb0c4dc7bb135574346834aae4 100644
--- a/boost/asio/detail/reactor.hpp
+++ b/boost/asio/detail/reactor.hpp
@@ -2,7 +2,7 @@
 // detail/reactor.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,18 +15,42 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include <boost/asio/detail/reactor_fwd.hpp>
+#include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_ASIO_HAS_EPOLL)
+#if defined(BOOST_ASIO_HAS_IOCP) || defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# include <boost/asio/detail/null_reactor.hpp>
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/null_reactor.hpp>
+#elif defined(BOOST_ASIO_HAS_EPOLL)
 # include <boost/asio/detail/epoll_reactor.hpp>
 #elif defined(BOOST_ASIO_HAS_KQUEUE)
 # include <boost/asio/detail/kqueue_reactor.hpp>
 #elif defined(BOOST_ASIO_HAS_DEV_POLL)
 # include <boost/asio/detail/dev_poll_reactor.hpp>
-#elif defined(BOOST_ASIO_HAS_IOCP) || defined(BOOST_ASIO_WINDOWS_RUNTIME)
-# include <boost/asio/detail/null_reactor.hpp>
 #else
 # include <boost/asio/detail/select_reactor.hpp>
 #endif
 
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if defined(BOOST_ASIO_HAS_IOCP) || defined(BOOST_ASIO_WINDOWS_RUNTIME)
+typedef null_reactor reactor;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+typedef null_reactor reactor;
+#elif defined(BOOST_ASIO_HAS_EPOLL)
+typedef epoll_reactor reactor;
+#elif defined(BOOST_ASIO_HAS_KQUEUE)
+typedef kqueue_reactor reactor;
+#elif defined(BOOST_ASIO_HAS_DEV_POLL)
+typedef dev_poll_reactor reactor;
+#else
+typedef select_reactor reactor;
+#endif
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
 #endif // BOOST_ASIO_DETAIL_REACTOR_HPP
diff --git a/boost/asio/detail/reactor_op.hpp b/boost/asio/detail/reactor_op.hpp
index eed3236eb983c837fa1c606b2e3b7ace3390c67a..c13e5890037fc1ea22700ed6bc43b5b4fc2187cf 100644
--- a/boost/asio/detail/reactor_op.hpp
+++ b/boost/asio/detail/reactor_op.hpp
@@ -2,7 +2,7 @@
 // detail/reactor_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -31,6 +31,9 @@ public:
   // The error code to be passed to the completion handler.
   boost::system::error_code ec_;
 
+  // The operation key used for targeted cancellation.
+  void* cancellation_key_;
+
   // The number of bytes transferred, to be passed to the completion handler.
   std::size_t bytes_transferred_;
 
@@ -51,6 +54,7 @@ protected:
       perform_func_type perform_func, func_type complete_func)
     : operation(complete_func),
       ec_(success_ec),
+      cancellation_key_(0),
       bytes_transferred_(0),
       perform_func_(perform_func)
   {
diff --git a/boost/asio/detail/reactor_op_queue.hpp b/boost/asio/detail/reactor_op_queue.hpp
index 51e29229272ea8d7d10df6eed7b2ce3a1f7374db..ef076ebdddfabc7959a69cf30cc4f0ea878f57e2 100644
--- a/boost/asio/detail/reactor_op_queue.hpp
+++ b/boost/asio/detail/reactor_op_queue.hpp
@@ -2,7 +2,7 @@
 // detail/reactor_op_queue.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -101,6 +101,50 @@ public:
     return this->cancel_operations(operations_.find(descriptor), ops, ec);
   }
 
+  // Cancel operations associated with the descriptor identified by the
+  // supplied iterator, and the specified cancellation key. Any operations
+  // pending for the descriptor with the key will be cancelled. Returns true if
+  // any operations were cancelled, in which case the reactor's event
+  // demultiplexing function may need to be interrupted and restarted.
+  bool cancel_operations_by_key(iterator i, op_queue<operation>& ops,
+      void* cancellation_key, const boost::system::error_code& ec =
+        boost::asio::error::operation_aborted)
+  {
+    bool result = false;
+    if (i != operations_.end())
+    {
+      op_queue<reactor_op> other_ops;
+      while (reactor_op* op = i->second.front())
+      {
+        i->second.pop();
+        if (op->cancellation_key_ == cancellation_key)
+        {
+          op->ec_ = ec;
+          ops.push(op);
+          result = true;
+        }
+        else
+          other_ops.push(op);
+      }
+      i->second.push(other_ops);
+      if (i->second.empty())
+        operations_.erase(i);
+    }
+    return result;
+  }
+
+  // Cancel all operations associated with the descriptor. Any operations
+  // pending for the descriptor will be cancelled. Returns true if any
+  // operations were cancelled, in which case the reactor's event
+  // demultiplexing function may need to be interrupted and restarted.
+  bool cancel_operations_by_key(Descriptor descriptor, op_queue<operation>& ops,
+      void* cancellation_key, const boost::system::error_code& ec =
+        boost::asio::error::operation_aborted)
+  {
+    return this->cancel_operations_by_key(
+        operations_.find(descriptor), ops, cancellation_key, ec);
+  }
+
   // Whether there are no operations in the queue.
   bool empty() const
   {
diff --git a/boost/asio/detail/recycling_allocator.hpp b/boost/asio/detail/recycling_allocator.hpp
index b185d88c01ce6b3164222176458c2d8f40f1f676..87a83959ea785b49162ff3348408022c27a8f2b0 100644
--- a/boost/asio/detail/recycling_allocator.hpp
+++ b/boost/asio/detail/recycling_allocator.hpp
@@ -2,7 +2,7 @@
 // detail/recycling_allocator.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -50,7 +50,8 @@ public:
   T* allocate(std::size_t n)
   {
     void* p = thread_info_base::allocate(Purpose(),
-        thread_context::top_of_thread_call_stack(), sizeof(T) * n);
+        thread_context::top_of_thread_call_stack(),
+        sizeof(T) * n, BOOST_ASIO_ALIGNOF(T));
     return static_cast<T*>(p);
   }
 
diff --git a/boost/asio/detail/regex_fwd.hpp b/boost/asio/detail/regex_fwd.hpp
index fc0160c4bb224e6374994f38cc063eafb7ee1cf7..be78fad6525cf1991664da1979dbd39cf622c9df 100644
--- a/boost/asio/detail/regex_fwd.hpp
+++ b/boost/asio/detail/regex_fwd.hpp
@@ -2,7 +2,7 @@
 // detail/regex_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/resolve_endpoint_op.hpp b/boost/asio/detail/resolve_endpoint_op.hpp
index 1947642a79b238233ebb13fcc7eddd2bd3b5e800..14426d97c9cea919229a62ba25e76644f3d1fba7 100644
--- a/boost/asio/detail/resolve_endpoint_op.hpp
+++ b/boost/asio/detail/resolve_endpoint_op.hpp
@@ -2,7 +2,7 @@
 // detail/resolve_endpoint_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -80,8 +80,8 @@ public:
       // the resolver operation.
     
       // Perform the blocking endpoint resolution operation.
-      char host_name[NI_MAXHOST];
-      char service_name[NI_MAXSERV];
+      char host_name[NI_MAXHOST] = "";
+      char service_name[NI_MAXSERV] = "";
       socket_ops::background_getnameinfo(o->cancel_token_, o->endpoint_.data(),
           o->endpoint_.size(), host_name, NI_MAXHOST, service_name, NI_MAXSERV,
           o->endpoint_.protocol().type(), o->ec_);
diff --git a/boost/asio/detail/resolve_op.hpp b/boost/asio/detail/resolve_op.hpp
index 123a580b3a3688d10f10abbef179018734d8d46e..fdb0cb9120b36c2ca3c3ebcde943d33a813aa7e7 100644
--- a/boost/asio/detail/resolve_op.hpp
+++ b/boost/asio/detail/resolve_op.hpp
@@ -2,7 +2,7 @@
 // detail/resolve_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/resolve_query_op.hpp b/boost/asio/detail/resolve_query_op.hpp
index 4191c391663af1b18a72ddbd508cd727915d5fcc..79aef04bd66ad47fea9b393a301d8ded678708f6 100644
--- a/boost/asio/detail/resolve_query_op.hpp
+++ b/boost/asio/detail/resolve_query_op.hpp
@@ -2,7 +2,7 @@
 // detail/resolve_query_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/resolver_service.hpp b/boost/asio/detail/resolver_service.hpp
index 46b01ecbae5a4fb1bb1d4c897c69cea3061e8447..5eb78b56a3bd817df896528d1590b7a5dc421a5c 100644
--- a/boost/asio/detail/resolver_service.hpp
+++ b/boost/asio/detail/resolver_service.hpp
@@ -2,7 +2,7 @@
 // detail/resolver_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/resolver_service_base.hpp b/boost/asio/detail/resolver_service_base.hpp
index 0d43bef91fcf25698b70c85945d06ffb307a4eae..3661cd4e48e841c1a240f3f8ffe982bb1657b950 100644
--- a/boost/asio/detail/resolver_service_base.hpp
+++ b/boost/asio/detail/resolver_service_base.hpp
@@ -2,7 +2,7 @@
 // detail/resolver_service_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/scheduler.hpp b/boost/asio/detail/scheduler.hpp
index dfff09e93e78c9066ebf5b0de078409793d01264..da02346bd5d63b3c839b694977c0dca2d5e68b77 100644
--- a/boost/asio/detail/scheduler.hpp
+++ b/boost/asio/detail/scheduler.hpp
@@ -2,7 +2,7 @@
 // detail/scheduler.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -23,8 +23,8 @@
 #include <boost/asio/detail/conditionally_enabled_event.hpp>
 #include <boost/asio/detail/conditionally_enabled_mutex.hpp>
 #include <boost/asio/detail/op_queue.hpp>
-#include <boost/asio/detail/reactor_fwd.hpp>
 #include <boost/asio/detail/scheduler_operation.hpp>
+#include <boost/asio/detail/scheduler_task.hpp>
 #include <boost/asio/detail/thread.hpp>
 #include <boost/asio/detail/thread_context.hpp>
 
@@ -43,10 +43,15 @@ class scheduler
 public:
   typedef scheduler_operation operation;
 
+  // The type of a function used to obtain a task instance.
+  typedef scheduler_task* (*get_task_func_type)(
+      boost::asio::execution_context&);
+
   // Constructor. Specifies the number of concurrent threads that are likely to
   // run the scheduler. If set to 1 certain optimisation are performed.
   BOOST_ASIO_DECL scheduler(boost::asio::execution_context& ctx,
-      int concurrency_hint = 0, bool own_thread = true);
+      int concurrency_hint = 0, bool own_thread = true,
+      get_task_func_type get_task = &scheduler::get_default_task);
 
   // Destructor.
   BOOST_ASIO_DECL ~scheduler();
@@ -166,6 +171,10 @@ private:
   BOOST_ASIO_DECL void wake_one_thread_and_unlock(
       mutex::scoped_lock& lock);
 
+  // Get the default task.
+  BOOST_ASIO_DECL static scheduler_task* get_default_task(
+      boost::asio::execution_context& ctx);
+
   // Helper class to run the scheduler in its own thread.
   class thread_function;
   friend class thread_function;
@@ -188,7 +197,10 @@ private:
   event wakeup_event_;
 
   // The task to be run by this service.
-  reactor* task_;
+  scheduler_task* task_;
+
+  // The function used to get the task.
+  get_task_func_type get_task_;
 
   // Operation object to represent the position of the task in the queue.
   struct task_operation : operation
diff --git a/boost/asio/detail/scheduler_operation.hpp b/boost/asio/detail/scheduler_operation.hpp
index bbe231f1d2780eb95a83b8445a78416a202024b0..387d13892ed63577f9fab3ff26f73e4d62f4d659 100644
--- a/boost/asio/detail/scheduler_operation.hpp
+++ b/boost/asio/detail/scheduler_operation.hpp
@@ -2,7 +2,7 @@
 // detail/scheduler_operation.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/scheduler_task.hpp b/boost/asio/detail/scheduler_task.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..eff848bf3bf104e5d40f56bb88bfcab9e8ccbc18
--- /dev/null
+++ b/boost/asio/detail/scheduler_task.hpp
@@ -0,0 +1,51 @@
+//
+// detail/scheduler_task.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_SCHEDULER_TASK_HPP
+#define BOOST_ASIO_DETAIL_SCHEDULER_TASK_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/op_queue.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class scheduler_operation;
+
+// Base class for all tasks that may be run by a scheduler.
+class scheduler_task
+{
+public:
+  // Run the task once until interrupted or events are ready to be dispatched.
+  virtual void run(long usec, op_queue<scheduler_operation>& ops) = 0;
+
+  // Interrupt the task.
+  virtual void interrupt() = 0;
+
+protected:
+  // Prevent deletion through this type.
+  ~scheduler_task()
+  {
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SCHEDULER_TASK_HPP
diff --git a/boost/asio/detail/scheduler_thread_info.hpp b/boost/asio/detail/scheduler_thread_info.hpp
index 9202fbaed6b728ad82a336fe2257da7e458fb560..327e1957e6a6595eefb5dd1da1e9a5ebcc0126cd 100644
--- a/boost/asio/detail/scheduler_thread_info.hpp
+++ b/boost/asio/detail/scheduler_thread_info.hpp
@@ -2,7 +2,7 @@
 // detail/scheduler_thread_info.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/scoped_lock.hpp b/boost/asio/detail/scoped_lock.hpp
index 71e072bf60b207b24995ac25115049444903c5c8..35f3c558f90aa394199815a5c06462800cbeb403 100644
--- a/boost/asio/detail/scoped_lock.hpp
+++ b/boost/asio/detail/scoped_lock.hpp
@@ -2,7 +2,7 @@
 // detail/scoped_lock.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/scoped_ptr.hpp b/boost/asio/detail/scoped_ptr.hpp
index f465890d1149d58b6d08e660f9dec6235f72e8e1..49bf48becf2bef4e2fb510f2464f84904f0d6027 100644
--- a/boost/asio/detail/scoped_ptr.hpp
+++ b/boost/asio/detail/scoped_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/scoped_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/select_interrupter.hpp b/boost/asio/detail/select_interrupter.hpp
index 485a66b949d3965c5026e69f2156743006f18b8e..f7417b6c1d63d9392614828bcb8c4c3c63e58c46 100644
--- a/boost/asio/detail/select_interrupter.hpp
+++ b/boost/asio/detail/select_interrupter.hpp
@@ -2,7 +2,7 @@
 // detail/select_interrupter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/select_reactor.hpp b/boost/asio/detail/select_reactor.hpp
index b5f0b782f5555725f6501f88615102004170e11d..a9294338c976d24c2fa7a4c171941b72439672e0 100644
--- a/boost/asio/detail/select_reactor.hpp
+++ b/boost/asio/detail/select_reactor.hpp
@@ -2,7 +2,7 @@
 // detail/select_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -30,6 +30,7 @@
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/reactor_op_queue.hpp>
+#include <boost/asio/detail/scheduler_task.hpp>
 #include <boost/asio/detail/select_interrupter.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
@@ -49,6 +50,9 @@ namespace detail {
 
 class select_reactor
   : public execution_context_service_base<select_reactor>
+#if !defined(BOOST_ASIO_HAS_IOCP)
+    , public scheduler_task
+#endif // !defined(BOOST_ASIO_HAS_IOCP)
 {
 public:
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -91,10 +95,7 @@ public:
       per_descriptor_data& descriptor_data, reactor_op* op);
 
   // Post a reactor operation for immediate completion.
-  void post_immediate_completion(reactor_op* op, bool is_continuation)
-  {
-    scheduler_.post_immediate_completion(op, is_continuation);
-  }
+  void post_immediate_completion(reactor_op* op, bool is_continuation);
 
   // Start a new operation. The reactor operation will be performed when the
   // given descriptor is flagged as ready, or an error has occurred.
@@ -106,6 +107,13 @@ public:
   // operation_aborted error.
   BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&);
 
+  // Cancel all operations associated with the given descriptor and key. The
+  // handlers associated with the descriptor will be invoked with the
+  // operation_aborted error.
+  BOOST_ASIO_DECL void cancel_ops_by_key(socket_type descriptor,
+      per_descriptor_data& descriptor_data,
+      int op_type, void* cancellation_key);
+
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor. The reactor resources associated with
   // the descriptor must be released by calling cleanup_descriptor_data.
@@ -149,6 +157,12 @@ public:
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Cancel the timer operations associated with the given key.
+  template <typename Time_Traits>
+  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data* timer,
+      void* cancellation_key);
+
   // Move the timer operations associated with the given timer.
   template <typename Time_Traits>
   void move_timer(timer_queue<Time_Traits>& queue,
diff --git a/boost/asio/detail/service_registry.hpp b/boost/asio/detail/service_registry.hpp
index 68aac83032de58ca3c29340c43d776334891a2c3..863d795b084b8139771056e71666c0cdb6bbd453 100644
--- a/boost/asio/detail/service_registry.hpp
+++ b/boost/asio/detail/service_registry.hpp
@@ -2,7 +2,7 @@
 // detail/service_registry.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/signal_blocker.hpp b/boost/asio/detail/signal_blocker.hpp
index d9aebc7d7762ae58c99304b7bd143f3fb9f49936..690aa5fdd0f30afb0992619649491ccd9f2e1bcc 100644
--- a/boost/asio/detail/signal_blocker.hpp
+++ b/boost/asio/detail/signal_blocker.hpp
@@ -2,7 +2,7 @@
 // detail/signal_blocker.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/signal_handler.hpp b/boost/asio/detail/signal_handler.hpp
index 8928c90af912886968411d6060bfd5d0c02cf9e1..a2825d1df9a4a0ac127f10ed435afc69115fb2c2 100644
--- a/boost/asio/detail/signal_handler.hpp
+++ b/boost/asio/detail/signal_handler.hpp
@@ -2,7 +2,7 @@
 // detail/signal_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/signal_init.hpp b/boost/asio/detail/signal_init.hpp
index 72d252b8075deccb52c9b1ef9d2e2dc6b7dd3b6d..e227d4898fbeb579fa7e6ea22eb68cd7280b5b50 100644
--- a/boost/asio/detail/signal_init.hpp
+++ b/boost/asio/detail/signal_init.hpp
@@ -2,7 +2,7 @@
 // detail/signal_init.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/signal_op.hpp b/boost/asio/detail/signal_op.hpp
index ad05dd78f7af1e0b03d6ad9bb8f351df69d8a115..0e12dc5bed2d960353c1cf9d93314f3f7cc51d0a 100644
--- a/boost/asio/detail/signal_op.hpp
+++ b/boost/asio/detail/signal_op.hpp
@@ -2,7 +2,7 @@
 // detail/signal_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -31,12 +31,16 @@ public:
   // The error code to be passed to the completion handler.
   boost::system::error_code ec_;
 
+  // The operation key used for targeted cancellation.
+  void* cancellation_key_;
+
   // The signal number to be passed to the completion handler.
   int signal_number_;
 
 protected:
   signal_op(func_type func)
     : operation(func),
+      cancellation_key_(0),
       signal_number_(0)
   {
   }
diff --git a/boost/asio/detail/signal_set_service.hpp b/boost/asio/detail/signal_set_service.hpp
index 8dfecb19f2b3e78c69dedd48819d4614e36bdb16..704861c322a8e8027438649d7cbfdfd675a8cc65 100644
--- a/boost/asio/detail/signal_set_service.hpp
+++ b/boost/asio/detail/signal_set_service.hpp
@@ -2,7 +2,7 @@
 // detail/signal_set_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,6 +19,8 @@
 
 #include <cstddef>
 #include <signal.h>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/cancellation_type.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/execution_context.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
@@ -35,7 +37,11 @@
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 #if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
-# include <boost/asio/detail/reactor.hpp>
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+#  include <boost/asio/detail/io_uring_service.hpp>
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+#  include <boost/asio/detail/reactor.hpp>
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 #endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
 #include <boost/asio/detail/push_options.hpp>
@@ -150,17 +156,31 @@ public:
   BOOST_ASIO_DECL boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec);
 
+  // Cancel a specific operation associated with the signal set.
+  BOOST_ASIO_DECL void cancel_ops_by_key(implementation_type& impl,
+      void* cancellation_key);
+
   // Start an asynchronous operation to wait for a signal to be delivered.
   template <typename Handler, typename IoExecutor>
   void async_wait(implementation_type& impl,
       Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef signal_handler<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<signal_op_cancellation>(this, &impl);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((scheduler_.context(),
           *p.p, "signal_set", &impl, 0, "async_wait"));
 
@@ -187,6 +207,32 @@ private:
   // Helper function to start a wait operation.
   BOOST_ASIO_DECL void start_wait_op(implementation_type& impl, signal_op* op);
 
+  // Helper class used to implement per-operation cancellation
+  class signal_op_cancellation
+  {
+  public:
+    signal_op_cancellation(signal_set_service* s, implementation_type* i)
+      : service_(s),
+        implementation_(i)
+    {
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+      if (!!(type &
+            (cancellation_type::terminal
+              | cancellation_type::partial
+              | cancellation_type::total)))
+      {
+        service_->cancel_ops_by_key(*implementation_, this);
+      }
+    }
+
+  private:
+    signal_set_service* service_;
+    implementation_type* implementation_;
+  };
+
   // The scheduler used for dispatching handlers.
 #if defined(BOOST_ASIO_HAS_IOCP)
   typedef class win_iocp_io_context scheduler_impl;
@@ -198,14 +244,22 @@ private:
 #if !defined(BOOST_ASIO_WINDOWS) \
   && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
   && !defined(__CYGWIN__)
-  // The type used for registering for pipe reactor notifications.
+  // The type used for processing pipe readiness notifications.
   class pipe_read_op;
 
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  // The io_uring service used for waiting for pipe readiness.
+  io_uring_service& io_uring_service_;
+
+  // The per I/O object data used for the pipe.
+  io_uring_service::per_io_object_data io_object_data_;
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
   // The reactor used for waiting for pipe readiness.
   reactor& reactor_;
 
   // The per-descriptor reactor data used for the pipe.
   reactor::per_descriptor_data reactor_data_;
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 #endif // !defined(BOOST_ASIO_WINDOWS)
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
        //   && !defined(__CYGWIN__)
diff --git a/boost/asio/detail/socket_holder.hpp b/boost/asio/detail/socket_holder.hpp
index e941fc554edf9d542342976518aba7fe5c252cf7..3c44dca3b6f9275fdd9895e92bd3442ada34d9ba 100644
--- a/boost/asio/detail/socket_holder.hpp
+++ b/boost/asio/detail/socket_holder.hpp
@@ -2,7 +2,7 @@
 // detail/socket_holder.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/socket_ops.hpp b/boost/asio/detail/socket_ops.hpp
index 0bb20d66956609eeb753b6d5a275f048c22cbc68..fea8ff216c8e8acb8654453898f571326cd95cac 100644
--- a/boost/asio/detail/socket_ops.hpp
+++ b/boost/asio/detail/socket_ops.hpp
@@ -2,7 +2,7 @@
 // detail/socket_ops.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/socket_option.hpp b/boost/asio/detail/socket_option.hpp
index 5eba4776d5fc31d8332ec2f8afe757f76ed745b9..e390fb007f28e3c43b2bd253510f7389dbb31984 100644
--- a/boost/asio/detail/socket_option.hpp
+++ b/boost/asio/detail/socket_option.hpp
@@ -2,7 +2,7 @@
 // detail/socket_option.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/socket_select_interrupter.hpp b/boost/asio/detail/socket_select_interrupter.hpp
index 382fb34619895b4246316147ea76f60d052ebc0b..dbd94ca163a072bc721adcb553f8b21c08989605 100644
--- a/boost/asio/detail/socket_select_interrupter.hpp
+++ b/boost/asio/detail/socket_select_interrupter.hpp
@@ -2,7 +2,7 @@
 // detail/socket_select_interrupter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/socket_types.hpp b/boost/asio/detail/socket_types.hpp
index 4099deec3728f08db55afe85ff918eee281b248a..4b308741b293ea29d908e864228836b730ac808e 100644
--- a/boost/asio/detail/socket_types.hpp
+++ b/boost/asio/detail/socket_types.hpp
@@ -2,7 +2,7 @@
 // detail/socket_types.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/solaris_fenced_block.hpp b/boost/asio/detail/solaris_fenced_block.hpp
index e87432ba73e9dd727dd35abb24e6c1246616f7d3..4e33186168892730bd42b25e3c6c76cf35f12008 100644
--- a/boost/asio/detail/solaris_fenced_block.hpp
+++ b/boost/asio/detail/solaris_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/solaris_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/source_location.hpp b/boost/asio/detail/source_location.hpp
index 094bed3b8599c7ef7e367d52e3f471a793674dfe..cddecf3a473106c25b0edd4aa040e77bfc928427 100644
--- a/boost/asio/detail/source_location.hpp
+++ b/boost/asio/detail/source_location.hpp
@@ -2,7 +2,7 @@
 // detail/source_location.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/static_mutex.hpp b/boost/asio/detail/static_mutex.hpp
index 5851bd7b457f59f3eae1ae1a3ee7117e59257e16..647a48d21fbcd590278d44e54375aac5cd959a29 100644
--- a/boost/asio/detail/static_mutex.hpp
+++ b/boost/asio/detail/static_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/static_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/std_event.hpp b/boost/asio/detail/std_event.hpp
index 68c8c8fe0374f31ed463d325f1e42df347f492b0..13aeb4a62709f0d53f8f2aa56063cf4e8a3e8177 100644
--- a/boost/asio/detail/std_event.hpp
+++ b/boost/asio/detail/std_event.hpp
@@ -2,7 +2,7 @@
 // detail/std_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/std_fenced_block.hpp b/boost/asio/detail/std_fenced_block.hpp
index 1617c4f9d7b602194ec9d762cefc927c2323c64b..0a5cfedbccecffd032a511e8701d93c1cc8a026e 100644
--- a/boost/asio/detail/std_fenced_block.hpp
+++ b/boost/asio/detail/std_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/std_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/std_global.hpp b/boost/asio/detail/std_global.hpp
index f4127e4ef2c1b7da3edd215de39a44a46cc75a6b..1a6ab9091667621375c6e1f32bf3593ed47f95c4 100644
--- a/boost/asio/detail/std_global.hpp
+++ b/boost/asio/detail/std_global.hpp
@@ -2,7 +2,7 @@
 // detail/std_global.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/std_mutex.hpp b/boost/asio/detail/std_mutex.hpp
index cb2b0bd401c4876e4c2fe4256b011caeeabdbf2c..7ecd903278fbe6d7ed4f6de10c5234aafd105192 100644
--- a/boost/asio/detail/std_mutex.hpp
+++ b/boost/asio/detail/std_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/std_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/std_static_mutex.hpp b/boost/asio/detail/std_static_mutex.hpp
index c87296262593631b5638241fd9619501ea85dc15..af590a1ecca2c6f883ac4389210ade57579ea67e 100644
--- a/boost/asio/detail/std_static_mutex.hpp
+++ b/boost/asio/detail/std_static_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/std_static_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/std_thread.hpp b/boost/asio/detail/std_thread.hpp
index 3d1d3d496963ddbcbc02446f3b4433809b0f3dc6..fc186f5d1fb95982ae5b55a13b94f775bc3108be 100644
--- a/boost/asio/detail/std_thread.hpp
+++ b/boost/asio/detail/std_thread.hpp
@@ -2,7 +2,7 @@
 // detail/std_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/strand_executor_service.hpp b/boost/asio/detail/strand_executor_service.hpp
index bb84f884de01d9d4333fe75ea6ee75efa0504a0a..9b3eb38cbd0f187f1a0eafe12516e110963a3afe 100644
--- a/boost/asio/detail/strand_executor_service.hpp
+++ b/boost/asio/detail/strand_executor_service.hpp
@@ -2,7 +2,7 @@
 // detail/strand_executor_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/strand_service.hpp b/boost/asio/detail/strand_service.hpp
index bff9322416bf189759faa725a1e1720d720b7a2e..016a6cfcd5834c0ac9bcc969d2ea38cf5bd51114 100644
--- a/boost/asio/detail/strand_service.hpp
+++ b/boost/asio/detail/strand_service.hpp
@@ -2,7 +2,7 @@
 // detail/strand_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/string_view.hpp b/boost/asio/detail/string_view.hpp
index 0a505a0ad4fbb9e8074913c61d2b6ccc0bff4c76..5cdaee56dcca38d00ed7ba2237d63622b1b9a62d 100644
--- a/boost/asio/detail/string_view.hpp
+++ b/boost/asio/detail/string_view.hpp
@@ -2,7 +2,7 @@
 // detail/string_view.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/thread.hpp b/boost/asio/detail/thread.hpp
index 42e23d361415dbf3b1667d6e1e74ed7dc90d453e..57e9cbce5780b3ec64e7973177e795f1e3d20e01 100644
--- a/boost/asio/detail/thread.hpp
+++ b/boost/asio/detail/thread.hpp
@@ -2,7 +2,7 @@
 // detail/thread.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/thread_context.hpp b/boost/asio/detail/thread_context.hpp
index 6bfed361d1acc497c5acdbb916404a837f4dda8d..6396dd37a31c1689619a84480548d394f872a75c 100644
--- a/boost/asio/detail/thread_context.hpp
+++ b/boost/asio/detail/thread_context.hpp
@@ -2,7 +2,7 @@
 // detail/thread_context.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/thread_group.hpp b/boost/asio/detail/thread_group.hpp
index 0acaf6c4d8e815da89a281e531a2d2427760cce1..ff91f397249c0fdb0045b2925f89c40721bb219d 100644
--- a/boost/asio/detail/thread_group.hpp
+++ b/boost/asio/detail/thread_group.hpp
@@ -2,7 +2,7 @@
 // detail/thread_group.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/thread_info_base.hpp b/boost/asio/detail/thread_info_base.hpp
index 0bd70416ad4bfeb1654fac051d284882dfdbffbf..fd976f918afa2eac1e267c7834ddf00d20a70545 100644
--- a/boost/asio/detail/thread_info_base.hpp
+++ b/boost/asio/detail/thread_info_base.hpp
@@ -2,7 +2,7 @@
 // detail/thread_info_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,6 +18,7 @@
 #include <boost/asio/detail/config.hpp>
 #include <climits>
 #include <cstddef>
+#include <boost/asio/detail/memory.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 
 #if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \
@@ -33,25 +34,66 @@ namespace boost {
 namespace asio {
 namespace detail {
 
+#ifndef BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE
+# define BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE 2
+#endif // BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE
+
 class thread_info_base
   : private noncopyable
 {
 public:
   struct default_tag
   {
-    enum { mem_index = 0 };
+    enum
+    {
+      cache_size = BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
+      begin_mem_index = 0,
+      end_mem_index = cache_size
+    };
   };
 
   struct awaitable_frame_tag
   {
-    enum { mem_index = 1 };
+    enum
+    {
+      cache_size = BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
+      begin_mem_index = default_tag::end_mem_index,
+      end_mem_index = begin_mem_index + cache_size
+    };
   };
 
   struct executor_function_tag
   {
-    enum { mem_index = 2 };
+    enum
+    {
+      cache_size = BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
+      begin_mem_index = awaitable_frame_tag::end_mem_index,
+      end_mem_index = begin_mem_index + cache_size
+    };
+  };
+
+  struct cancellation_signal_tag
+  {
+    enum
+    {
+      cache_size = BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
+      begin_mem_index = executor_function_tag::end_mem_index,
+      end_mem_index = begin_mem_index + cache_size
+    };
+  };
+
+  struct parallel_group_tag
+  {
+    enum
+    {
+      cache_size = BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
+      begin_mem_index = cancellation_signal_tag::end_mem_index,
+      end_mem_index = begin_mem_index + cache_size
+    };
   };
 
+  enum { max_mem_index = parallel_group_tag::end_mem_index };
+
   thread_info_base()
 #if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \
   && !defined(BOOST_ASIO_NO_EXCEPTIONS)
@@ -71,13 +113,14 @@ public:
       // it is significantly faster when using a tight io_context::poll() loop
       // in latency sensitive applications.
       if (reusable_memory_[i])
-        ::operator delete(reusable_memory_[i]);
+        aligned_delete(reusable_memory_[i]);
     }
   }
 
-  static void* allocate(thread_info_base* this_thread, std::size_t size)
+  static void* allocate(thread_info_base* this_thread,
+      std::size_t size, std::size_t align = BOOST_ASIO_DEFAULT_ALIGN)
   {
-    return allocate(default_tag(), this_thread, size);
+    return allocate(default_tag(), this_thread, size, align);
   }
 
   static void deallocate(thread_info_base* this_thread,
@@ -88,26 +131,43 @@ public:
 
   template <typename Purpose>
   static void* allocate(Purpose, thread_info_base* this_thread,
-      std::size_t size)
+      std::size_t size, std::size_t align = BOOST_ASIO_DEFAULT_ALIGN)
   {
     std::size_t chunks = (size + chunk_size - 1) / chunk_size;
 
-    if (this_thread && this_thread->reusable_memory_[Purpose::mem_index])
+    if (this_thread)
     {
-      void* const pointer = this_thread->reusable_memory_[Purpose::mem_index];
-      this_thread->reusable_memory_[Purpose::mem_index] = 0;
-
-      unsigned char* const mem = static_cast<unsigned char*>(pointer);
-      if (static_cast<std::size_t>(mem[0]) >= chunks)
+      for (int mem_index = Purpose::begin_mem_index;
+          mem_index < Purpose::end_mem_index; ++mem_index)
       {
-        mem[size] = mem[0];
-        return pointer;
+        if (this_thread->reusable_memory_[mem_index])
+        {
+          void* const pointer = this_thread->reusable_memory_[mem_index];
+          unsigned char* const mem = static_cast<unsigned char*>(pointer);
+          if (static_cast<std::size_t>(mem[0]) >= chunks
+              && reinterpret_cast<std::size_t>(pointer) % align == 0)
+          {
+            this_thread->reusable_memory_[mem_index] = 0;
+            mem[size] = mem[0];
+            return pointer;
+          }
+        }
       }
 
-      ::operator delete(pointer);
+      for (int mem_index = Purpose::begin_mem_index;
+          mem_index < Purpose::end_mem_index; ++mem_index)
+      {
+        if (this_thread->reusable_memory_[mem_index])
+        {
+          void* const pointer = this_thread->reusable_memory_[mem_index];
+          this_thread->reusable_memory_[mem_index] = 0;
+          aligned_delete(pointer);
+          break;
+        }
+      }
     }
 
-    void* const pointer = ::operator new(chunks * chunk_size + 1);
+    void* const pointer = aligned_new(align, chunks * chunk_size + 1);
     unsigned char* const mem = static_cast<unsigned char*>(pointer);
     mem[size] = (chunks <= UCHAR_MAX) ? static_cast<unsigned char>(chunks) : 0;
     return pointer;
@@ -119,16 +179,23 @@ public:
   {
     if (size <= chunk_size * UCHAR_MAX)
     {
-      if (this_thread && this_thread->reusable_memory_[Purpose::mem_index] == 0)
+      if (this_thread)
       {
-        unsigned char* const mem = static_cast<unsigned char*>(pointer);
-        mem[0] = mem[size];
-        this_thread->reusable_memory_[Purpose::mem_index] = pointer;
-        return;
+        for (int mem_index = Purpose::begin_mem_index;
+            mem_index < Purpose::end_mem_index; ++mem_index)
+        {
+          if (this_thread->reusable_memory_[mem_index] == 0)
+          {
+            unsigned char* const mem = static_cast<unsigned char*>(pointer);
+            mem[0] = mem[size];
+            this_thread->reusable_memory_[mem_index] = pointer;
+            return;
+          }
+        }
       }
     }
 
-    ::operator delete(pointer);
+    aligned_delete(pointer);
   }
 
   void capture_current_exception()
@@ -171,8 +238,11 @@ public:
   }
 
 private:
+#if defined(BOOST_ASIO_HAS_IO_URING)
+  enum { chunk_size = 8 };
+#else // defined(BOOST_ASIO_HAS_IO_URING)
   enum { chunk_size = 4 };
-  enum { max_mem_index = 3 };
+#endif // defined(BOOST_ASIO_HAS_IO_URING)
   void* reusable_memory_[max_mem_index];
 
 #if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \
diff --git a/boost/asio/detail/throw_error.hpp b/boost/asio/detail/throw_error.hpp
index aa8aaf1133b47a5b2947139e279121d2e03e714b..554254190d89f15e52e7a1a08faae4210bbf4c07 100644
--- a/boost/asio/detail/throw_error.hpp
+++ b/boost/asio/detail/throw_error.hpp
@@ -2,7 +2,7 @@
 // detail/throw_error.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/throw_exception.hpp b/boost/asio/detail/throw_exception.hpp
index 2dae79b207ad94af599330848b3a98044a1f5b07..3fec04cb79f5efd706dc378c2149aa1bc6d3dbdc 100644
--- a/boost/asio/detail/throw_exception.hpp
+++ b/boost/asio/detail/throw_exception.hpp
@@ -2,7 +2,7 @@
 // detail/throw_exception.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/timer_queue.hpp b/boost/asio/detail/timer_queue.hpp
index c8d573b99ac9a5f921da96ecd0f10b50ca8750c8..2a973430d96aafa36b47718761a12c8e19534a3a 100644
--- a/boost/asio/detail/timer_queue.hpp
+++ b/boost/asio/detail/timer_queue.hpp
@@ -2,7 +2,7 @@
 // detail/timer_queue.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -151,7 +151,12 @@ public:
       while (!heap_.empty() && !Time_Traits::less_than(now, heap_[0].time_))
       {
         per_timer_data* timer = heap_[0].timer_;
-        ops.push(timer->op_queue_);
+        while (wait_op* op = timer->op_queue_.front())
+        {
+          timer->op_queue_.pop();
+          op->ec_ = boost::system::error_code();
+          ops.push(op);
+        }
         remove_timer(*timer);
       }
     }
@@ -193,6 +198,30 @@ public:
     return num_cancelled;
   }
 
+  // Cancel and dequeue a specific operation for the given timer.
+  void cancel_timer_by_key(per_timer_data* timer,
+      op_queue<operation>& ops, void* cancellation_key)
+  {
+    if (timer->prev_ != 0 || timer == timers_)
+    {
+      op_queue<wait_op> other_ops;
+      while (wait_op* op = timer->op_queue_.front())
+      {
+        timer->op_queue_.pop();
+        if (op->cancellation_key_ == cancellation_key)
+        {
+          op->ec_ = boost::asio::error::operation_aborted;
+          ops.push(op);
+        }
+        else
+          other_ops.push(op);
+      }
+      timer->op_queue_.push(other_ops);
+      if (timer->op_queue_.empty())
+        remove_timer(*timer);
+    }
+  }
+
   // Move operations from one timer to another, empty timer.
   void move_timer(per_timer_data& target, per_timer_data& source)
   {
diff --git a/boost/asio/detail/timer_queue_base.hpp b/boost/asio/detail/timer_queue_base.hpp
index 0330579f102a284594a6cdc11632537cd2e4cf7c..c20ccc9862c89dbaaa85f1064e53bcc91cf30941 100644
--- a/boost/asio/detail/timer_queue_base.hpp
+++ b/boost/asio/detail/timer_queue_base.hpp
@@ -2,7 +2,7 @@
 // detail/timer_queue_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/timer_queue_ptime.hpp b/boost/asio/detail/timer_queue_ptime.hpp
index 2e4980d6527e78afe9165c67fbe71c31472b0433..6d0f94009a60c194534e53f9842f954af20e0206 100644
--- a/boost/asio/detail/timer_queue_ptime.hpp
+++ b/boost/asio/detail/timer_queue_ptime.hpp
@@ -2,7 +2,7 @@
 // detail/timer_queue_ptime.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -78,6 +78,10 @@ public:
       per_timer_data& timer, op_queue<operation>& ops,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Cancel and dequeue operations for the given timer and key.
+  BOOST_ASIO_DECL void cancel_timer_by_key(per_timer_data* timer,
+      op_queue<operation>& ops, void* cancellation_key);
+
   // Move operations from one timer to another, empty timer.
   BOOST_ASIO_DECL void move_timer(per_timer_data& target,
       per_timer_data& source);
diff --git a/boost/asio/detail/timer_queue_set.hpp b/boost/asio/detail/timer_queue_set.hpp
index 53ad1a8d345ca30262d099ee0ec0f599f54dab67..783adfb72899aa3193dec1156c082e6f274ec1cf 100644
--- a/boost/asio/detail/timer_queue_set.hpp
+++ b/boost/asio/detail/timer_queue_set.hpp
@@ -2,7 +2,7 @@
 // detail/timer_queue_set.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/timer_scheduler.hpp b/boost/asio/detail/timer_scheduler.hpp
index 0522043e6b73d36d2e9ae1031b3f4c52229c15e1..01001aafccf78efe8c3ac17d68c2ecb415e50083 100644
--- a/boost/asio/detail/timer_scheduler.hpp
+++ b/boost/asio/detail/timer_scheduler.hpp
@@ -2,7 +2,7 @@
 // detail/timer_scheduler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -22,6 +22,8 @@
 # include <boost/asio/detail/winrt_timer_scheduler.hpp>
 #elif defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_io_context.hpp>
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/io_uring_service.hpp>
 #elif defined(BOOST_ASIO_HAS_EPOLL)
 # include <boost/asio/detail/epoll_reactor.hpp>
 #elif defined(BOOST_ASIO_HAS_KQUEUE)
diff --git a/boost/asio/detail/timer_scheduler_fwd.hpp b/boost/asio/detail/timer_scheduler_fwd.hpp
index e10bacc37da3fa1aa10774f396d47d8a63a4005a..abb4f93019d121d9dc9edccef845e1d7b19c9c84 100644
--- a/boost/asio/detail/timer_scheduler_fwd.hpp
+++ b/boost/asio/detail/timer_scheduler_fwd.hpp
@@ -2,7 +2,7 @@
 // detail/timer_scheduler_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -25,6 +25,8 @@ namespace detail {
 typedef class winrt_timer_scheduler timer_scheduler;
 #elif defined(BOOST_ASIO_HAS_IOCP)
 typedef class win_iocp_io_context timer_scheduler;
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+typedef class io_uring_service timer_scheduler;
 #elif defined(BOOST_ASIO_HAS_EPOLL)
 typedef class epoll_reactor timer_scheduler;
 #elif defined(BOOST_ASIO_HAS_KQUEUE)
diff --git a/boost/asio/detail/tss_ptr.hpp b/boost/asio/detail/tss_ptr.hpp
index a32c2f106a6711d96129150a93152d64fd9caf81..92deeaaf228983d8f114bf416a3f60a86c6efbde 100644
--- a/boost/asio/detail/tss_ptr.hpp
+++ b/boost/asio/detail/tss_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/type_traits.hpp b/boost/asio/detail/type_traits.hpp
index e477d38043fac87c8e415e6fe78b397128351c04..5fb091b1bca312bae54a60a3569f315ab6e804c1 100644
--- a/boost/asio/detail/type_traits.hpp
+++ b/boost/asio/detail/type_traits.hpp
@@ -2,7 +2,7 @@
 // detail/type_traits.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/variadic_templates.hpp b/boost/asio/detail/variadic_templates.hpp
index 5fbe3e39bb3ba7341bd603ee6e14b7a2d405a652..fea03044ff031f00f63d994aedd9b60e739624f2 100644
--- a/boost/asio/detail/variadic_templates.hpp
+++ b/boost/asio/detail/variadic_templates.hpp
@@ -2,7 +2,7 @@
 // detail/variadic_templates.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/wait_handler.hpp b/boost/asio/detail/wait_handler.hpp
index 4075543e10d4a5fef0ab47c341b51c60857858da..f2c253731d479361b5d342030e169d1a6679be29 100644
--- a/boost/asio/detail/wait_handler.hpp
+++ b/boost/asio/detail/wait_handler.hpp
@@ -2,7 +2,7 @@
 // detail/wait_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/wait_op.hpp b/boost/asio/detail/wait_op.hpp
index 23ab8f0bbc4008e983f36c99d211998205d51dfa..15d57cf574ea30dfe48dd540fc659b67a8e9df7b 100644
--- a/boost/asio/detail/wait_op.hpp
+++ b/boost/asio/detail/wait_op.hpp
@@ -2,7 +2,7 @@
 // detail/wait_op.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -31,9 +31,13 @@ public:
   // The error code to be passed to the completion handler.
   boost::system::error_code ec_;
 
+  // The operation key used for targeted cancellation.
+  void* cancellation_key_;
+
 protected:
   wait_op(func_type func)
-    : operation(func)
+    : operation(func),
+      cancellation_key_(0)
   {
   }
 };
diff --git a/boost/asio/detail/win_event.hpp b/boost/asio/detail/win_event.hpp
index 9928bd2cc6ab77b5a147ceb0651c5a6ece1d0468..48e90a17f2f5361ad43b69f58372ba78b35c60f1 100644
--- a/boost/asio/detail/win_event.hpp
+++ b/boost/asio/detail/win_event.hpp
@@ -2,7 +2,7 @@
 // detail/win_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_fd_set_adapter.hpp b/boost/asio/detail/win_fd_set_adapter.hpp
index 3ace61360fd3469e4fbac0b57e8b4d6c95d4d229..5e91303d7c9e70fecd0f2f537d7f9fb7f5333e50 100644
--- a/boost/asio/detail/win_fd_set_adapter.hpp
+++ b/boost/asio/detail/win_fd_set_adapter.hpp
@@ -2,7 +2,7 @@
 // detail/win_fd_set_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_fenced_block.hpp b/boost/asio/detail/win_fenced_block.hpp
index ff556e4957ced17668aa2b969ae02a8812b8ae30..8d32720a964de2cf0d1d601df3be360d9d0699b0 100644
--- a/boost/asio/detail/win_fenced_block.hpp
+++ b/boost/asio/detail/win_fenced_block.hpp
@@ -2,7 +2,7 @@
 // detail/win_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_global.hpp b/boost/asio/detail/win_global.hpp
index a58013691ebbb81ed44d23da95b4add327302ecf..b54d5c395bb1904a6c2fc6b68be0ae2aa981f5b4 100644
--- a/boost/asio/detail/win_global.hpp
+++ b/boost/asio/detail/win_global.hpp
@@ -2,7 +2,7 @@
 // detail/win_global.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_iocp_file_service.hpp b/boost/asio/detail/win_iocp_file_service.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b66882fd4b4c1a8215ec508fa343964c0c572fc9
--- /dev/null
+++ b/boost/asio/detail/win_iocp_file_service.hpp
@@ -0,0 +1,289 @@
+//
+// detail/win_iocp_file_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_WIN_IOCP_FILE_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_WIN_IOCP_FILE_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IOCP) && defined(BOOST_ASIO_HAS_FILE)
+
+#include <string>
+#include <boost/asio/detail/cstdint.hpp>
+#include <boost/asio/detail/win_iocp_handle_service.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/file_base.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Extend win_iocp_handle_service to provide file support.
+class win_iocp_file_service :
+  public execution_context_service_base<win_iocp_file_service>
+{
+public:
+  // The native type of a file.
+  typedef win_iocp_handle_service::native_handle_type native_handle_type;
+
+  // The implementation type of the file.
+  class implementation_type : win_iocp_handle_service::implementation_type
+  {
+  private:
+    // Only this service will have access to the internal values.
+    friend class win_iocp_file_service;
+
+    uint64_t offset_;
+    bool is_stream_;
+  };
+
+  // Constructor.
+  BOOST_ASIO_DECL win_iocp_file_service(execution_context& context);
+
+  // Destroy all user-defined handler objects owned by the service.
+  BOOST_ASIO_DECL void shutdown();
+
+  // Construct a new file implementation.
+  void construct(implementation_type& impl)
+  {
+    handle_service_.construct(impl);
+    impl.offset_ = 0;
+    impl.is_stream_ = false;
+  }
+
+  // Move-construct a new file implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    handle_service_.move_construct(impl, other_impl);
+    impl.offset_ = other_impl.offset_;
+    impl.is_stream_ = other_impl.is_stream_;
+    other_impl.offset_ = 0;
+  }
+
+  // Move-assign from another file implementation.
+  void move_assign(implementation_type& impl,
+      win_iocp_file_service& other_service,
+      implementation_type& other_impl)
+  {
+    handle_service_.move_assign(impl,
+        other_service.handle_service_, other_impl);
+    impl.offset_ = other_impl.offset_;
+    impl.is_stream_ = other_impl.is_stream_;
+    other_impl.offset_ = 0;
+  }
+
+  // Destroy a file implementation.
+  void destroy(implementation_type& impl)
+  {
+    handle_service_.destroy(impl);
+  }
+
+  // Set whether the implementation is stream-oriented.
+  void set_is_stream(implementation_type& impl, bool is_stream)
+  {
+    impl.is_stream_ = is_stream;
+  }
+
+  // Open the file using the specified path name.
+  BOOST_ASIO_DECL boost::system::error_code open(implementation_type& impl,
+      const char* path, file_base::flags open_flags,
+      boost::system::error_code& ec);
+
+  // Assign a native handle to a file implementation.
+  boost::system::error_code assign(implementation_type& impl,
+      const native_handle_type& native_handle,
+      boost::system::error_code& ec)
+  {
+    return handle_service_.assign(impl, native_handle, ec);
+  }
+
+  // Determine whether the file is open.
+  bool is_open(const implementation_type& impl) const
+  {
+    return handle_service_.is_open(impl);
+  }
+
+  // Destroy a file implementation.
+  boost::system::error_code close(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    return handle_service_.close(impl, ec);
+  }
+
+  // Get the native file representation.
+  native_handle_type native_handle(const implementation_type& impl) const
+  {
+    return handle_service_.native_handle(impl);
+  }
+
+  // Release ownership of a file.
+  native_handle_type release(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    return handle_service_.release(impl, ec);
+  }
+
+  // Cancel all operations associated with the file.
+  boost::system::error_code cancel(implementation_type& impl,
+      boost::system::error_code& ec)
+  {
+    return handle_service_.cancel(impl, ec);
+  }
+
+  // Get the size of the file.
+  BOOST_ASIO_DECL uint64_t size(const implementation_type& impl,
+      boost::system::error_code& ec) const;
+
+  // Alter the size of the file.
+  BOOST_ASIO_DECL boost::system::error_code resize(implementation_type& impl,
+      uint64_t n, boost::system::error_code& ec);
+
+  // Synchronise the file to disk.
+  BOOST_ASIO_DECL boost::system::error_code sync_all(implementation_type& impl,
+      boost::system::error_code& ec);
+
+  // Synchronise the file data to disk.
+  BOOST_ASIO_DECL boost::system::error_code sync_data(implementation_type& impl,
+      boost::system::error_code& ec);
+
+  // Seek to a position in the file.
+  BOOST_ASIO_DECL uint64_t seek(implementation_type& impl, int64_t offset,
+      file_base::seek_basis whence, boost::system::error_code& ec);
+
+  // Write the given data. Returns the number of bytes written.
+  template <typename ConstBufferSequence>
+  size_t write_some(implementation_type& impl,
+      const ConstBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    uint64_t offset = impl.offset_;
+    impl.offset_ += boost::asio::buffer_size(buffers);
+    return handle_service_.write_some_at(impl, offset, buffers, ec);
+  }
+
+  // Start an asynchronous write. The data being written must be valid for the
+  // lifetime of the asynchronous operation.
+  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
+  void async_write_some(implementation_type& impl,
+      const ConstBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    uint64_t offset = impl.offset_;
+    impl.offset_ += boost::asio::buffer_size(buffers);
+    handle_service_.async_write_some_at(impl, offset, buffers, handler, io_ex);
+  }
+
+  // Write the given data at the specified location. Returns the number of
+  // bytes written.
+  template <typename ConstBufferSequence>
+  size_t write_some_at(implementation_type& impl, uint64_t offset,
+      const ConstBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    return handle_service_.write_some_at(impl, offset, buffers, ec);
+  }
+
+  // Start an asynchronous write at the specified location. The data being
+  // written must be valid for the lifetime of the asynchronous operation.
+  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
+  void async_write_some_at(implementation_type& impl,
+      uint64_t offset, const ConstBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    handle_service_.async_write_some_at(impl, offset, buffers, handler, io_ex);
+  }
+
+  // Read some data. Returns the number of bytes read.
+  template <typename MutableBufferSequence>
+  size_t read_some(implementation_type& impl,
+      const MutableBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    uint64_t offset = impl.offset_;
+    impl.offset_ += boost::asio::buffer_size(buffers);
+    return handle_service_.read_some_at(impl, offset, buffers, ec);
+  }
+
+  // Start an asynchronous read. The buffer for the data being read must be
+  // valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence,
+      typename Handler, typename IoExecutor>
+  void async_read_some(implementation_type& impl,
+      const MutableBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    uint64_t offset = impl.offset_;
+    impl.offset_ += boost::asio::buffer_size(buffers);
+    handle_service_.async_read_some_at(impl, offset, buffers, handler, io_ex);
+  }
+
+  // Read some data. Returns the number of bytes read.
+  template <typename MutableBufferSequence>
+  size_t read_some_at(implementation_type& impl, uint64_t offset,
+      const MutableBufferSequence& buffers, boost::system::error_code& ec)
+  {
+    return handle_service_.read_some_at(impl, offset, buffers, ec);
+  }
+
+  // Start an asynchronous read. The buffer for the data being read must be
+  // valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence,
+      typename Handler, typename IoExecutor>
+  void async_read_some_at(implementation_type& impl,
+      uint64_t offset, const MutableBufferSequence& buffers,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    handle_service_.async_read_some_at(impl, offset, buffers, handler, io_ex);
+  }
+
+private:
+  // The implementation used for initiating asynchronous operations.
+  win_iocp_handle_service handle_service_;
+
+  // Emulation of Windows IO_STATUS_BLOCK structure.
+  struct io_status_block
+  {
+    union u
+    {
+      LONG Status;
+      void* Pointer;
+    };
+    ULONG_PTR Information;
+  };
+
+  // Emulation of flag passed to NtFlushBuffersFileEx.
+  enum { flush_flags_file_data_sync_only = 4 };
+
+  // The type of a NtFlushBuffersFileEx function pointer.
+  typedef LONG (NTAPI *nt_flush_buffers_file_ex_fn)(
+      HANDLE, ULONG, void*, ULONG, io_status_block*);
+
+  // The NTFlushBuffersFileEx function pointer.
+  nt_flush_buffers_file_ex_fn nt_flush_buffers_file_ex_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/detail/impl/win_iocp_file_service.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // defined(BOOST_ASIO_HAS_IOCP) && defined(BOOST_ASIO_HAS_FILE)
+
+#endif // BOOST_ASIO_DETAIL_WIN_IOCP_FILE_SERVICE_HPP
diff --git a/boost/asio/detail/win_iocp_handle_read_op.hpp b/boost/asio/detail/win_iocp_handle_read_op.hpp
index 82e96238d67b87ae6225975b2ff043575d10b57e..8aef2237c6b4bd88da387e01fdd4d6aa956224d1 100644
--- a/boost/asio/detail/win_iocp_handle_read_op.hpp
+++ b/boost/asio/detail/win_iocp_handle_read_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_handle_read_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/detail/win_iocp_handle_service.hpp b/boost/asio/detail/win_iocp_handle_service.hpp
index 93abb752a7495eae136f902211697f87bdc96c53..561571580904051c97075d8c92bf5b88d65a9ee0 100644
--- a/boost/asio/detail/win_iocp_handle_service.hpp
+++ b/boost/asio/detail/win_iocp_handle_service.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_handle_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -20,6 +20,7 @@
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
+#include <boost/asio/associated_cancellation_slot.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/execution_context.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
@@ -110,6 +111,10 @@ public:
   BOOST_ASIO_DECL boost::system::error_code close(implementation_type& impl,
       boost::system::error_code& ec);
 
+  // Release ownership of a handle.
+  BOOST_ASIO_DECL native_handle_type release(implementation_type& impl,
+      boost::system::error_code& ec);
+
   // Get the native handle representation.
   native_handle_type native_handle(const implementation_type& impl) const
   {
@@ -148,19 +153,26 @@ public:
       const ConstBufferSequence& buffers,
       Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_handle_write_op<
         ConstBufferSequence, Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(buffers, handler, io_ex);
+    operation* o = p.p = new (p.v) op(buffers, handler, io_ex);
 
     BOOST_ASIO_HANDLER_CREATION((iocp_service_.context(), *p.p, "handle", &impl,
           reinterpret_cast<uintmax_t>(impl.handle_), "async_write_some"));
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+      o = &slot.template emplace<iocp_op_cancellation>(impl.handle_, o);
+
     start_write_op(impl, 0,
         buffer_sequence_adapter<boost::asio::const_buffer,
-          ConstBufferSequence>::first(buffers), p.p);
+          ConstBufferSequence>::first(buffers), o);
     p.v = p.p = 0;
   }
 
@@ -171,19 +183,26 @@ public:
       uint64_t offset, const ConstBufferSequence& buffers,
       Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_handle_write_op<
         ConstBufferSequence, Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(buffers, handler, io_ex);
+    operation* o = p.p = new (p.v) op(buffers, handler, io_ex);
 
     BOOST_ASIO_HANDLER_CREATION((iocp_service_.context(), *p.p, "handle", &impl,
           reinterpret_cast<uintmax_t>(impl.handle_), "async_write_some_at"));
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+      o = &slot.template emplace<iocp_op_cancellation>(impl.handle_, o);
+
     start_write_op(impl, offset,
         buffer_sequence_adapter<boost::asio::const_buffer,
-          ConstBufferSequence>::first(buffers), p.p);
+          ConstBufferSequence>::first(buffers), o);
     p.v = p.p = 0;
   }
 
@@ -215,19 +234,26 @@ public:
       const MutableBufferSequence& buffers,
       Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_handle_read_op<
         MutableBufferSequence, Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(buffers, handler, io_ex);
+    operation* o = p.p = new (p.v) op(buffers, handler, io_ex);
 
     BOOST_ASIO_HANDLER_CREATION((iocp_service_.context(), *p.p, "handle", &impl,
           reinterpret_cast<uintmax_t>(impl.handle_), "async_read_some"));
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+      o = &slot.template emplace<iocp_op_cancellation>(impl.handle_, o);
+
     start_read_op(impl, 0,
         buffer_sequence_adapter<boost::asio::mutable_buffer,
-          MutableBufferSequence>::first(buffers), p.p);
+          MutableBufferSequence>::first(buffers), o);
     p.v = p.p = 0;
   }
 
@@ -240,19 +266,26 @@ public:
       uint64_t offset, const MutableBufferSequence& buffers,
       Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_handle_read_op<
         MutableBufferSequence, Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(buffers, handler, io_ex);
+    operation* o = p.p = new (p.v) op(buffers, handler, io_ex);
 
     BOOST_ASIO_HANDLER_CREATION((iocp_service_.context(), *p.p, "handle", &impl,
           reinterpret_cast<uintmax_t>(impl.handle_), "async_read_some_at"));
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+      o = &slot.template emplace<iocp_op_cancellation>(impl.handle_, o);
+
     start_read_op(impl, offset,
         buffer_sequence_adapter<boost::asio::mutable_buffer,
-          MutableBufferSequence>::first(buffers), p.p);
+          MutableBufferSequence>::first(buffers), o);
     p.v = p.p = 0;
   }
 
@@ -311,10 +344,73 @@ private:
   // destroyed.
   BOOST_ASIO_DECL void close_for_destruction(implementation_type& impl);
 
+  // The type of a NtSetInformationFile function pointer.
+  typedef LONG (NTAPI *nt_set_info_fn)(HANDLE, ULONG_PTR*, void*, ULONG, ULONG);
+
+  // Helper function to get the NtSetInformationFile function pointer. If no
+  // NtSetInformationFile pointer has been obtained yet, one is obtained using
+  // GetProcAddress and the pointer is cached. Returns a null pointer if
+  // NtSetInformationFile is not available.
+  BOOST_ASIO_DECL nt_set_info_fn get_nt_set_info();
+
+  // Helper function to emulate InterlockedCompareExchangePointer functionality
+  // for:
+  // - very old Platform SDKs; and
+  // - platform SDKs where MSVC's /Wp64 option causes spurious warnings.
+  BOOST_ASIO_DECL void* interlocked_compare_exchange_pointer(
+      void** dest, void* exch, void* cmp);
+
+  // Helper function to emulate InterlockedExchangePointer functionality for:
+  // - very old Platform SDKs; and
+  // - platform SDKs where MSVC's /Wp64 option causes spurious warnings.
+  BOOST_ASIO_DECL void* interlocked_exchange_pointer(void** dest, void* val);
+
+  // Helper class used to implement per operation cancellation.
+  class iocp_op_cancellation : public operation
+  {
+  public:
+    iocp_op_cancellation(HANDLE h, operation* target)
+      : operation(&iocp_op_cancellation::do_complete),
+        handle_(h),
+        target_(target)
+    {
+    }
+
+    static void do_complete(void* owner, operation* base,
+        const boost::system::error_code& result_ec,
+        std::size_t bytes_transferred)
+    {
+      iocp_op_cancellation* o = static_cast<iocp_op_cancellation*>(base);
+      o->target_->complete(owner, result_ec, bytes_transferred);
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
+      if (!!(type &
+            (cancellation_type::terminal
+              | cancellation_type::partial
+              | cancellation_type::total)))
+      {
+        ::CancelIoEx(handle_, this);
+      }
+#else // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
+      (void)type;
+#endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
+    }
+
+  private:
+    HANDLE handle_;
+    operation* target_;
+  };
+
   // The IOCP service used for running asynchronous operations and dispatching
   // handlers.
   win_iocp_io_context& iocp_service_;
 
+  // Pointer to NtSetInformationFile implementation.
+  void* nt_set_info_;
+
   // Mutex to protect access to the linked list of implementations.
   mutex mutex_;
 
diff --git a/boost/asio/detail/win_iocp_handle_write_op.hpp b/boost/asio/detail/win_iocp_handle_write_op.hpp
index 9dd34417fedb7e878439fd9c15a9cc94d2362ba7..eeb4328e63f38133bdadaef1fd0a7f0390b4d1d5 100644
--- a/boost/asio/detail/win_iocp_handle_write_op.hpp
+++ b/boost/asio/detail/win_iocp_handle_write_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_handle_write_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/detail/win_iocp_io_context.hpp b/boost/asio/detail/win_iocp_io_context.hpp
index 517dbd5f707fbbd6752017e272af329fc3daedf7..abb69b2b535552e31330e22d4beedfecd0b6c472 100644
--- a/boost/asio/detail/win_iocp_io_context.hpp
+++ b/boost/asio/detail/win_iocp_io_context.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_io_context.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -198,6 +198,12 @@ public:
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Cancel the timer operations associated with the given key.
+  template <typename Time_Traits>
+  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data* timer,
+      void* cancellation_key);
+
   // Move the timer operations associated with the given timer.
   template <typename Time_Traits>
   void move_timer(timer_queue<Time_Traits>& queue,
diff --git a/boost/asio/detail/win_iocp_null_buffers_op.hpp b/boost/asio/detail/win_iocp_null_buffers_op.hpp
index 5980568cac4827d955a9e4e26ab09e5c27951e6e..acd6a0e12482367c04d0715a323d0b8a05459af7 100644
--- a/boost/asio/detail/win_iocp_null_buffers_op.hpp
+++ b/boost/asio/detail/win_iocp_null_buffers_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_null_buffers_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_iocp_operation.hpp b/boost/asio/detail/win_iocp_operation.hpp
index 910e962de49ace6fc980734468f1e100fa3f40ed..2b2dc67442e49cc1b9662bbd8145c40ca87f0b72 100644
--- a/boost/asio/detail/win_iocp_operation.hpp
+++ b/boost/asio/detail/win_iocp_operation.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_operation.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -52,6 +52,16 @@ public:
     func_(0, this, boost::system::error_code(), 0);
   }
 
+  void reset()
+  {
+    Internal = 0;
+    InternalHigh = 0;
+    Offset = 0;
+    OffsetHigh = 0;
+    hEvent = 0;
+    ready_ = 0;
+  }
+
 protected:
   typedef void (*func_type)(
       void*, win_iocp_operation*,
@@ -69,16 +79,6 @@ protected:
   {
   }
 
-  void reset()
-  {
-    Internal = 0;
-    InternalHigh = 0;
-    Offset = 0;
-    OffsetHigh = 0;
-    hEvent = 0;
-    ready_ = 0;
-  }
-
 private:
   friend class op_queue_access;
   friend class win_iocp_io_context;
diff --git a/boost/asio/detail/win_iocp_overlapped_op.hpp b/boost/asio/detail/win_iocp_overlapped_op.hpp
index eaf228390f33f3e1c23fd4bbb3c2d28541be3bba..7a4ffaaa392a6d045ea0b8914fddd2ab1f0bdcf1 100644
--- a/boost/asio/detail/win_iocp_overlapped_op.hpp
+++ b/boost/asio/detail/win_iocp_overlapped_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_overlapped_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_iocp_overlapped_ptr.hpp b/boost/asio/detail/win_iocp_overlapped_ptr.hpp
index 250e6d4774a244f45aa9c94c574e2a1dc6e01db9..d44ae97cb8b19978948435b72833c1f51b9a2887 100644
--- a/boost/asio/detail/win_iocp_overlapped_ptr.hpp
+++ b/boost/asio/detail/win_iocp_overlapped_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_overlapped_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_iocp_serial_port_service.hpp b/boost/asio/detail/win_iocp_serial_port_service.hpp
index 6d9b3a0b6f0954e1527726df8554d509761a92b7..53ef55832c285f3bae40f39ae7595402867749b3 100644
--- a/boost/asio/detail/win_iocp_serial_port_service.hpp
+++ b/boost/asio/detail/win_iocp_serial_port_service.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_serial_port_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/detail/win_iocp_socket_accept_op.hpp b/boost/asio/detail/win_iocp_socket_accept_op.hpp
index 46f81504cfbd746e5f2d88be9b2a2e3d509d4dd8..497d04b25f840c5f162bf75cdb05628895af6133 100644
--- a/boost/asio/detail/win_iocp_socket_accept_op.hpp
+++ b/boost/asio/detail/win_iocp_socket_accept_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_accept_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -54,6 +54,8 @@ public:
       protocol_(protocol),
       peer_endpoint_(peer_endpoint),
       enable_connection_aborted_(enable_connection_aborted),
+      proxy_op_(0),
+      cancel_requested_(0),
       handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
       work_(handler_, io_ex)
   {
@@ -74,6 +76,12 @@ public:
     return sizeof(sockaddr_storage_type) + 16;
   }
 
+  void enable_cancellation(long* cancel_requested, operation* proxy_op)
+  {
+    cancel_requested_ = cancel_requested;
+    proxy_op_ = proxy_op;
+  }
+
   static void do_complete(void* owner, operation* base,
       const boost::system::error_code& result_ec,
       std::size_t /*bytes_transferred*/)
@@ -99,10 +107,13 @@ public:
           && !o->enable_connection_aborted_)
       {
         o->reset();
+        if (o->proxy_op_)
+          o->proxy_op_->reset();
         o->socket_service_.restart_accept_op(o->socket_,
             o->new_socket_, o->protocol_.family(),
             o->protocol_.type(), o->protocol_.protocol(),
-            o->output_buffer(), o->address_length(), o);
+            o->output_buffer(), o->address_length(),
+            o->cancel_requested_, o->proxy_op_ ? o->proxy_op_ : o);
         p.v = p.p = 0;
         return;
       }
@@ -160,6 +171,8 @@ private:
   typename Protocol::endpoint* peer_endpoint_;
   unsigned char output_buffer_[(sizeof(sockaddr_storage_type) + 16) * 2];
   bool enable_connection_aborted_;
+  operation* proxy_op_;
+  long* cancel_requested_;
   Handler handler_;
   handler_work<Handler, IoExecutor> work_;
 };
@@ -185,6 +198,8 @@ public:
       protocol_(protocol),
       peer_endpoint_(peer_endpoint),
       enable_connection_aborted_(enable_connection_aborted),
+      cancel_requested_(0),
+      proxy_op_(0),
       handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
       work_(handler_, io_ex)
   {
@@ -205,6 +220,12 @@ public:
     return sizeof(sockaddr_storage_type) + 16;
   }
 
+  void enable_cancellation(long* cancel_requested, operation* proxy_op)
+  {
+    cancel_requested_ = cancel_requested;
+    proxy_op_ = proxy_op;
+  }
+
   static void do_complete(void* owner, operation* base,
       const boost::system::error_code& result_ec,
       std::size_t /*bytes_transferred*/)
@@ -231,10 +252,13 @@ public:
           && !o->enable_connection_aborted_)
       {
         o->reset();
+        if (o->proxy_op_)
+          o->proxy_op_->reset();
         o->socket_service_.restart_accept_op(o->socket_,
             o->new_socket_, o->protocol_.family(),
             o->protocol_.type(), o->protocol_.protocol(),
-            o->output_buffer(), o->address_length(), o);
+            o->output_buffer(), o->address_length(),
+            o->cancel_requested_, o->proxy_op_ ? o->proxy_op_ : o);
         p.v = p.p = 0;
         return;
       }
@@ -297,6 +321,8 @@ private:
   typename Protocol::endpoint* peer_endpoint_;
   unsigned char output_buffer_[(sizeof(sockaddr_storage_type) + 16) * 2];
   bool enable_connection_aborted_;
+  long* cancel_requested_;
+  operation* proxy_op_;
   Handler handler_;
   handler_work<Handler, IoExecutor> work_;
 };
diff --git a/boost/asio/detail/win_iocp_socket_connect_op.hpp b/boost/asio/detail/win_iocp_socket_connect_op.hpp
index ba85c93cf41a28e9f2544dfdf06844441228d412..e1a27a395c609eba1527dd372b5f733602ecc307 100644
--- a/boost/asio/detail/win_iocp_socket_connect_op.hpp
+++ b/boost/asio/detail/win_iocp_socket_connect_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_connect_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_iocp_socket_recv_op.hpp b/boost/asio/detail/win_iocp_socket_recv_op.hpp
index 0e29b34d39092a87b183ea80999e521900413cca..07f9615c11be742e01b9fe478afce0629db4983e 100644
--- a/boost/asio/detail/win_iocp_socket_recv_op.hpp
+++ b/boost/asio/detail/win_iocp_socket_recv_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_recv_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp b/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp
index df36fc0329eef34ce877159ca543f416d70e8e23..5dc43304ba5511db92666c943400b0c083fcc9c8 100644
--- a/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp
+++ b/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_recvfrom_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp b/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp
index 9dfad9b006261808da441a13b52d1a9d30e04ba7..eeee402e79b2ae6b1b00bf91f90857ecadfd5ca9 100644
--- a/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp
+++ b/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_recvmsg_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_iocp_socket_send_op.hpp b/boost/asio/detail/win_iocp_socket_send_op.hpp
index f54aeb8a12d6eb0236cb51d0773c42be9ff21844..011cbe9b22910d72a8b9ff81ae8e01c6586113a6 100644
--- a/boost/asio/detail/win_iocp_socket_send_op.hpp
+++ b/boost/asio/detail/win_iocp_socket_send_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_send_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_iocp_socket_service.hpp b/boost/asio/detail/win_iocp_socket_service.hpp
index 16335a510f5d1415cbea25e3852fb18481ee6633..6a324dd8fdf046b18e8a6a47b67e8f30fe9d6cbb 100644
--- a/boost/asio/detail/win_iocp_socket_service.hpp
+++ b/boost/asio/detail/win_iocp_socket_service.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -331,12 +331,16 @@ public:
       socket_base::message_flags flags, Handler& handler,
       const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_send_op<
         ConstBufferSequence, Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl.cancel_token_, buffers, handler, io_ex);
+    operation* o = p.p = new (p.v) op(
+        impl.cancel_token_, buffers, handler, io_ex);
 
     BOOST_ASIO_HANDLER_CREATION((context_, *p.p, "socket",
           &impl, impl.socket_, "async_send_to"));
@@ -344,9 +348,13 @@ public:
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(buffers);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+      o = &slot.template emplace<iocp_op_cancellation>(impl.socket_, o);
+
     start_send_to_op(impl, bufs.buffers(), bufs.count(),
         destination.data(), static_cast<int>(destination.size()),
-        flags, p.p);
+        flags, o);
     p.v = p.p = 0;
   }
 
@@ -360,12 +368,12 @@ public:
     typedef win_iocp_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl.cancel_token_, handler, io_ex);
+    reactor_op* o = p.p = new (p.v) op(impl.cancel_token_, handler, io_ex);
 
     BOOST_ASIO_HANDLER_CREATION((context_, *p.p, "socket",
           &impl, impl.socket_, "async_send_to(null_buffers)"));
 
-    start_reactor_op(impl, select_reactor::write_op, p.p);
+    start_reactor_op(impl, select_reactor::write_op, o);
     p.v = p.p = 0;
   }
 
@@ -415,13 +423,16 @@ public:
       socket_base::message_flags flags, Handler& handler,
       const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_recvfrom_op<MutableBufferSequence,
         endpoint_type, Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(sender_endp, impl.cancel_token_,
-        buffers, handler, io_ex);
+    operation* o = p.p = new (p.v) op(sender_endp,
+        impl.cancel_token_, buffers, handler, io_ex);
 
     BOOST_ASIO_HANDLER_CREATION((context_, *p.p, "socket",
           &impl, impl.socket_, "async_receive_from"));
@@ -429,8 +440,12 @@ public:
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+      o = &slot.template emplace<iocp_op_cancellation>(impl.socket_, o);
+
     start_receive_from_op(impl, bufs.buffers(), bufs.count(),
-        sender_endp.data(), flags, &p.p->endpoint_size(), p.p);
+        sender_endp.data(), flags, &p.p->endpoint_size(), o);
     p.v = p.p = 0;
   }
 
@@ -440,6 +455,9 @@ public:
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
       Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
@@ -452,8 +470,24 @@ public:
     // Reset endpoint since it can be given no sensible value at this time.
     sender_endpoint = endpoint_type();
 
-    start_null_buffers_receive_op(impl, flags, p.p);
+    // Optionally register for per-operation cancellation.
+    operation* iocp_op = p.p;
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ = iocp_op =
+        &slot.template emplace<reactor_op_cancellation>(
+            impl.socket_, iocp_op);
+    }
+
+    int op_type = start_null_buffers_receive_op(impl, flags, p.p, iocp_op);
     p.v = p.p = 0;
+
+    // Update cancellation method if the reactor was used.
+    if (slot.is_connected() && op_type != -1)
+    {
+      static_cast<reactor_op_cancellation*>(iocp_op)->use_reactor(
+          &get_reactor(), &impl.reactor_data_, op_type);
+    }
   }
 
   // Accept a new connection.
@@ -492,6 +526,9 @@ public:
   void async_accept(implementation_type& impl, Socket& peer,
       endpoint_type* peer_endpoint, Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_accept_op<Socket,
         protocol_type, Handler, IoExecutor> op;
@@ -499,16 +536,25 @@ public:
       op::ptr::allocate(handler), 0 };
     bool enable_connection_aborted =
       (impl.state_ & socket_ops::enable_connection_aborted) != 0;
-    p.p = new (p.v) op(*this, impl.socket_, peer, impl.protocol_,
+    operation* o = p.p = new (p.v) op(*this, impl.socket_, peer, impl.protocol_,
         peer_endpoint, enable_connection_aborted, handler, io_ex);
 
     BOOST_ASIO_HANDLER_CREATION((context_, *p.p, "socket",
           &impl, impl.socket_, "async_accept"));
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      accept_op_cancellation* c =
+        &slot.template emplace<accept_op_cancellation>(impl.socket_, o);
+      p.p->enable_cancellation(c->get_cancel_requested(), c);
+      o = c;
+    }
+
     start_accept_op(impl, peer.is_open(), p.p->new_socket(),
         impl.protocol_.family(), impl.protocol_.type(),
         impl.protocol_.protocol(), p.p->output_buffer(),
-        p.p->address_length(), p.p);
+        p.p->address_length(), o);
     p.v = p.p = 0;
   }
 
@@ -520,6 +566,9 @@ public:
       const PeerIoExecutor& peer_io_ex, endpoint_type* peer_endpoint,
       Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_move_accept_op<
         protocol_type, PeerIoExecutor, Handler, IoExecutor> op;
@@ -527,17 +576,26 @@ public:
       op::ptr::allocate(handler), 0 };
     bool enable_connection_aborted =
       (impl.state_ & socket_ops::enable_connection_aborted) != 0;
-    p.p = new (p.v) op(*this, impl.socket_, impl.protocol_,
+    operation* o = p.p = new (p.v) op(*this, impl.socket_, impl.protocol_,
         peer_io_ex, peer_endpoint, enable_connection_aborted,
         handler, io_ex);
 
     BOOST_ASIO_HANDLER_CREATION((context_, *p.p, "socket",
           &impl, impl.socket_, "async_accept"));
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      accept_op_cancellation* c =
+        &slot.template emplace<accept_op_cancellation>(impl.socket_, o);
+      p.p->enable_cancellation(c->get_cancel_requested(), c);
+      o = c;
+    }
+
     start_accept_op(impl, false, p.p->new_socket(),
         impl.protocol_.family(), impl.protocol_.type(),
         impl.protocol_.protocol(), p.p->output_buffer(),
-        p.p->address_length(), p.p);
+        p.p->address_length(), o);
     p.v = p.p = 0;
   }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
@@ -557,6 +615,9 @@ public:
       const endpoint_type& peer_endpoint, Handler& handler,
       const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_connect_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
@@ -566,9 +627,26 @@ public:
     BOOST_ASIO_HANDLER_CREATION((context_, *p.p, "socket",
           &impl, impl.socket_, "async_connect"));
 
-    start_connect_op(impl, impl.protocol_.family(), impl.protocol_.type(),
-        peer_endpoint.data(), static_cast<int>(peer_endpoint.size()), p.p);
+    // Optionally register for per-operation cancellation.
+    operation* iocp_op = p.p;
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ = iocp_op =
+        &slot.template emplace<reactor_op_cancellation>(
+            impl.socket_, iocp_op);
+    }
+
+    int op_type = start_connect_op(impl, impl.protocol_.family(),
+        impl.protocol_.type(), peer_endpoint.data(),
+        static_cast<int>(peer_endpoint.size()), p.p, iocp_op);
     p.v = p.p = 0;
+
+    // Update cancellation method if the reactor was used.
+    if (slot.is_connected() && op_type != -1)
+    {
+      static_cast<reactor_op_cancellation*>(iocp_op)->use_reactor(
+          &get_reactor(), &impl.reactor_data_, op_type);
+    }
   }
 };
 
diff --git a/boost/asio/detail/win_iocp_socket_service_base.hpp b/boost/asio/detail/win_iocp_socket_service_base.hpp
index 6cfb30af7a947c2bf264b954bd034b5ff9d872c7..d5805bf96441c9c516764023816af07f7ae8e2ab 100644
--- a/boost/asio/detail/win_iocp_socket_service_base.hpp
+++ b/boost/asio/detail/win_iocp_socket_service_base.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_socket_service_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,6 +19,7 @@
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
+#include <boost/asio/associated_cancellation_slot.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/execution_context.hpp>
 #include <boost/asio/socket_base.hpp>
@@ -214,6 +215,9 @@ public:
   void async_wait(base_implementation_type& impl,
       socket_base::wait_type w, Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
@@ -226,15 +230,27 @@ public:
     BOOST_ASIO_HANDLER_CREATION((context_, *p.p, "socket",
           &impl, impl.socket_, "async_wait"));
 
+    // Optionally register for per-operation cancellation.
+    operation* iocp_op = p.p;
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ = iocp_op =
+        &slot.template emplace<reactor_op_cancellation>(
+            impl.socket_, iocp_op);
+    }
+
+    int op_type = -1;
     switch (w)
     {
       case socket_base::wait_read:
-        start_null_buffers_receive_op(impl, 0, p.p);
+        op_type = start_null_buffers_receive_op(impl, 0, p.p, iocp_op);
         break;
       case socket_base::wait_write:
+        op_type = select_reactor::write_op;
         start_reactor_op(impl, select_reactor::write_op, p.p);
         break;
       case socket_base::wait_error:
+        op_type = select_reactor::read_op;
         start_reactor_op(impl, select_reactor::except_op, p.p);
         break;
       default:
@@ -244,6 +260,13 @@ public:
     }
 
     p.v = p.p = 0;
+
+    // Update cancellation method if the reactor was used.
+    if (slot.is_connected() && op_type != -1)
+    {
+      static_cast<reactor_op_cancellation*>(iocp_op)->use_reactor(
+          &get_reactor(), &impl.reactor_data_, op_type);
+    }
   }
 
   // Send the given data to the peer. Returns the number of bytes sent.
@@ -276,12 +299,16 @@ public:
       const ConstBufferSequence& buffers, socket_base::message_flags flags,
       Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_send_op<
         ConstBufferSequence, Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl.cancel_token_, buffers, handler, io_ex);
+    operation* o = p.p = new (p.v) op(
+        impl.cancel_token_, buffers, handler, io_ex);
 
     BOOST_ASIO_HANDLER_CREATION((context_, *p.p, "socket",
           &impl, impl.socket_, "async_send"));
@@ -289,9 +316,13 @@ public:
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(buffers);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+      o = &slot.template emplace<iocp_op_cancellation>(impl.socket_, o);
+
     start_send_op(impl, bufs.buffers(), bufs.count(), flags,
         (impl.state_ & socket_ops::stream_oriented) != 0 && bufs.all_empty(),
-        p.p);
+        o);
     p.v = p.p = 0;
   }
 
@@ -344,13 +375,16 @@ public:
       const MutableBufferSequence& buffers, socket_base::message_flags flags,
       Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_recv_op<
         MutableBufferSequence, Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl.state_, impl.cancel_token_,
-        buffers, handler, io_ex);
+    operation* o = p.p = new (p.v) op(impl.state_,
+        impl.cancel_token_, buffers, handler, io_ex);
 
     BOOST_ASIO_HANDLER_CREATION((context_, *p.p, "socket",
           &impl, impl.socket_, "async_receive"));
@@ -358,9 +392,13 @@ public:
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+      o = &slot.template emplace<iocp_op_cancellation>(impl.socket_, o);
+
     start_receive_op(impl, bufs.buffers(), bufs.count(), flags,
         (impl.state_ & socket_ops::stream_oriented) != 0 && bufs.all_empty(),
-        p.p);
+        o);
     p.v = p.p = 0;
   }
 
@@ -370,6 +408,9 @@ public:
       const null_buffers&, socket_base::message_flags flags,
       Handler& handler, const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
@@ -379,8 +420,24 @@ public:
     BOOST_ASIO_HANDLER_CREATION((context_, *p.p, "socket",
           &impl, impl.socket_, "async_receive(null_buffers)"));
 
-    start_null_buffers_receive_op(impl, flags, p.p);
+    // Optionally register for per-operation cancellation.
+    operation* iocp_op = p.p;
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ = iocp_op =
+        &slot.template emplace<reactor_op_cancellation>(
+            impl.socket_, iocp_op);
+    }
+
+    int op_type = start_null_buffers_receive_op(impl, flags, p.p, iocp_op);
     p.v = p.p = 0;
+
+    // Update cancellation method if the reactor was used.
+    if (slot.is_connected() && op_type != -1)
+    {
+      static_cast<reactor_op_cancellation*>(iocp_op)->use_reactor(
+          &get_reactor(), &impl.reactor_data_, op_type);
+    }
   }
 
   // Receive some data with associated flags. Returns the number of bytes
@@ -422,12 +479,15 @@ public:
       socket_base::message_flags& out_flags, Handler& handler,
       const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_recvmsg_op<
         MutableBufferSequence, Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl.cancel_token_,
+    operation* o = p.p = new (p.v) op(impl.cancel_token_,
         buffers, out_flags, handler, io_ex);
 
     BOOST_ASIO_HANDLER_CREATION((context_, *p.p, "socket",
@@ -436,7 +496,11 @@ public:
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
 
-    start_receive_op(impl, bufs.buffers(), bufs.count(), in_flags, false, p.p);
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+      o = &slot.template emplace<iocp_op_cancellation>(impl.socket_, o);
+
+    start_receive_op(impl, bufs.buffers(), bufs.count(), in_flags, false, o);
     p.v = p.p = 0;
   }
 
@@ -447,6 +511,9 @@ public:
       socket_base::message_flags& out_flags, Handler& handler,
       const IoExecutor& io_ex)
   {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
@@ -459,14 +526,31 @@ public:
     // Reset out_flags since it can be given no sensible value at this time.
     out_flags = 0;
 
-    start_null_buffers_receive_op(impl, in_flags, p.p);
+    // Optionally register for per-operation cancellation.
+    operation* iocp_op = p.p;
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ = iocp_op =
+        &slot.template emplace<reactor_op_cancellation>(
+            impl.socket_, iocp_op);
+    }
+
+    int op_type = start_null_buffers_receive_op(impl, in_flags, p.p, iocp_op);
     p.v = p.p = 0;
+
+    // Update cancellation method if the reactor was used.
+    if (slot.is_connected() && op_type != -1)
+    {
+      static_cast<reactor_op_cancellation*>(iocp_op)->use_reactor(
+          &get_reactor(), &impl.reactor_data_, op_type);
+    }
   }
 
   // Helper function to restart an asynchronous accept operation.
   BOOST_ASIO_DECL void restart_accept_op(socket_type s,
-      socket_holder& new_socket, int family, int type, int protocol,
-      void* output_buffer, DWORD address_length, operation* op);
+      socket_holder& new_socket, int family, int type,
+      int protocol, void* output_buffer, DWORD address_length,
+      long* cancel_requested, operation* op);
 
 protected:
   // Open a new socket implementation.
@@ -496,9 +580,9 @@ protected:
       socket_base::message_flags flags, bool noop, operation* op);
 
   // Helper function to start an asynchronous null_buffers receive operation.
-  BOOST_ASIO_DECL void start_null_buffers_receive_op(
-      base_implementation_type& impl,
-      socket_base::message_flags flags, reactor_op* op);
+  BOOST_ASIO_DECL int start_null_buffers_receive_op(
+      base_implementation_type& impl, socket_base::message_flags flags,
+      reactor_op* op, operation* iocp_op);
 
   // Helper function to start an asynchronous receive_from operation.
   BOOST_ASIO_DECL void start_receive_from_op(base_implementation_type& impl,
@@ -515,9 +599,10 @@ protected:
       int op_type, reactor_op* op);
 
   // Start the asynchronous connect operation using the reactor.
-  BOOST_ASIO_DECL void start_connect_op(base_implementation_type& impl,
+  BOOST_ASIO_DECL int start_connect_op(base_implementation_type& impl,
       int family, int type, const socket_addr_type* remote_addr,
-      std::size_t remote_addrlen, win_iocp_socket_connect_op_base* op);
+      std::size_t remote_addrlen, win_iocp_socket_connect_op_base* op,
+      operation* iocp_op);
 
   // Helper function to close a socket when the associated object is being
   // destroyed.
@@ -563,6 +648,153 @@ protected:
   // - platform SDKs where MSVC's /Wp64 option causes spurious warnings.
   BOOST_ASIO_DECL void* interlocked_exchange_pointer(void** dest, void* val);
 
+  // Helper class used to implement per operation cancellation.
+  class iocp_op_cancellation : public operation
+  {
+  public:
+    iocp_op_cancellation(SOCKET s, operation* target)
+      : operation(&iocp_op_cancellation::do_complete),
+        socket_(s),
+        target_(target)
+    {
+    }
+
+    static void do_complete(void* owner, operation* base,
+        const boost::system::error_code& result_ec,
+        std::size_t bytes_transferred)
+    {
+      iocp_op_cancellation* o = static_cast<iocp_op_cancellation*>(base);
+      o->target_->complete(owner, result_ec, bytes_transferred);
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
+      if (!!(type &
+            (cancellation_type::terminal
+              | cancellation_type::partial
+              | cancellation_type::total)))
+      {
+        HANDLE sock_as_handle = reinterpret_cast<HANDLE>(socket_);
+        ::CancelIoEx(sock_as_handle, this);
+      }
+#else // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
+      (void)type;
+#endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
+    }
+
+  private:
+    SOCKET socket_;
+    operation* target_;
+  };
+
+  // Helper class used to implement per operation cancellation.
+  class accept_op_cancellation : public operation
+  {
+  public:
+    accept_op_cancellation(SOCKET s, operation* target)
+      : operation(&iocp_op_cancellation::do_complete),
+        socket_(s),
+        target_(target),
+        cancel_requested_(0)
+    {
+    }
+
+    static void do_complete(void* owner, operation* base,
+        const boost::system::error_code& result_ec,
+        std::size_t bytes_transferred)
+    {
+      accept_op_cancellation* o = static_cast<accept_op_cancellation*>(base);
+      o->target_->complete(owner, result_ec, bytes_transferred);
+    }
+
+    long* get_cancel_requested()
+    {
+      return &cancel_requested_;
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
+      if (!!(type &
+            (cancellation_type::terminal
+              | cancellation_type::partial
+              | cancellation_type::total)))
+      {
+        HANDLE sock_as_handle = reinterpret_cast<HANDLE>(socket_);
+        ::CancelIoEx(sock_as_handle, this);
+      }
+#else // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
+      (void)type;
+#endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
+    }
+
+  private:
+    SOCKET socket_;
+    operation* target_;
+    long cancel_requested_;
+  };
+
+  // Helper class used to implement per operation cancellation.
+  class reactor_op_cancellation : public operation
+  {
+  public:
+    reactor_op_cancellation(SOCKET s, operation* base)
+      : operation(&reactor_op_cancellation::do_complete),
+        socket_(s),
+        target_(base),
+        reactor_(0),
+        reactor_data_(0),
+        op_type_(-1)
+    {
+    }
+
+    void use_reactor(select_reactor* r,
+        select_reactor::per_descriptor_data* p, int o)
+    {
+      reactor_ = r;
+      reactor_data_ = p;
+      op_type_ = o;
+    }
+
+    static void do_complete(void* owner, operation* base,
+        const boost::system::error_code& result_ec,
+        std::size_t bytes_transferred)
+    {
+      reactor_op_cancellation* o = static_cast<reactor_op_cancellation*>(base);
+      o->target_->complete(owner, result_ec, bytes_transferred);
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+      if (!!(type &
+            (cancellation_type::terminal
+              | cancellation_type::partial
+              | cancellation_type::total)))
+      {
+        if (reactor_)
+        {
+          reactor_->cancel_ops_by_key(socket_,
+              *reactor_data_, op_type_, this);
+        }
+        else
+        {
+#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
+          HANDLE sock_as_handle = reinterpret_cast<HANDLE>(socket_);
+          ::CancelIoEx(sock_as_handle, this);
+#endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
+        }
+      }
+    }
+
+  private:
+    SOCKET socket_;
+    operation* target_;
+    select_reactor* reactor_;
+    select_reactor::per_descriptor_data* reactor_data_;
+    int op_type_;
+  };
+
   // The execution context used to obtain the reactor, if required.
   execution_context& context_;
 
diff --git a/boost/asio/detail/win_iocp_thread_info.hpp b/boost/asio/detail/win_iocp_thread_info.hpp
index 3bab06c25678bb3ba2419d1901301a1577ce8089..8b5aca12f7906999b833d0c12a47cd97db844919 100644
--- a/boost/asio/detail/win_iocp_thread_info.hpp
+++ b/boost/asio/detail/win_iocp_thread_info.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_thread_info.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_iocp_wait_op.hpp b/boost/asio/detail/win_iocp_wait_op.hpp
index f08092a7dd41974608d0052a6b82fc91b20d97cc..fef582184b43c26968f15236ce6f51df50217786 100644
--- a/boost/asio/detail/win_iocp_wait_op.hpp
+++ b/boost/asio/detail/win_iocp_wait_op.hpp
@@ -2,7 +2,7 @@
 // detail/win_iocp_wait_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_mutex.hpp b/boost/asio/detail/win_mutex.hpp
index e4ac87df4934370c31430d968bf5772a912c04ef..b79aa8e7365a33eea3fa45899eb09f6a11437d55 100644
--- a/boost/asio/detail/win_mutex.hpp
+++ b/boost/asio/detail/win_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/win_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_object_handle_service.hpp b/boost/asio/detail/win_object_handle_service.hpp
index 678bb85329d3fe0ded1b7ee679e44e0f8726c534..ded47990d970eef46d57ccde1b3ebe221258ed90 100644
--- a/boost/asio/detail/win_object_handle_service.hpp
+++ b/boost/asio/detail/win_object_handle_service.hpp
@@ -2,7 +2,7 @@
 // detail/win_object_handle_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/detail/win_static_mutex.hpp b/boost/asio/detail/win_static_mutex.hpp
index e2af539c6a3741760968ce8cb047b2091156bae2..2111e2882f53b422645cd837e8dfcfc7005c011a 100644
--- a/boost/asio/detail/win_static_mutex.hpp
+++ b/boost/asio/detail/win_static_mutex.hpp
@@ -2,7 +2,7 @@
 // detail/win_static_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_thread.hpp b/boost/asio/detail/win_thread.hpp
index 83e34cc18d03722bfd21e63a479d6f00ee7d1434..f471896d89c4a8e18df3e2c9b3b2df9f403fa98b 100644
--- a/boost/asio/detail/win_thread.hpp
+++ b/boost/asio/detail/win_thread.hpp
@@ -2,7 +2,7 @@
 // detail/win_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/win_tss_ptr.hpp b/boost/asio/detail/win_tss_ptr.hpp
index ad9030eedf751018ecf641868200e91bdf1010f6..05b62bad24d71e2a6593ac170073b3f7eacedd8e 100644
--- a/boost/asio/detail/win_tss_ptr.hpp
+++ b/boost/asio/detail/win_tss_ptr.hpp
@@ -2,7 +2,7 @@
 // detail/win_tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/winapp_thread.hpp b/boost/asio/detail/winapp_thread.hpp
index 416ade7829481c6120d97e3ea66056c5443959e4..b79b3f2870938ae4f20420bce00bb95a9bfba773 100644
--- a/boost/asio/detail/winapp_thread.hpp
+++ b/boost/asio/detail/winapp_thread.hpp
@@ -2,7 +2,7 @@
 // detail/winapp_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/wince_thread.hpp b/boost/asio/detail/wince_thread.hpp
index 38541f219b6400b712e18b43600bbad0484085d6..66239f7a0b554ef679d2bd35d42d4c220527a1ae 100644
--- a/boost/asio/detail/wince_thread.hpp
+++ b/boost/asio/detail/wince_thread.hpp
@@ -2,7 +2,7 @@
 // detail/wince_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/winrt_async_manager.hpp b/boost/asio/detail/winrt_async_manager.hpp
index fd4e4c74980d510ce5b1cbaf2cae2c9de1a27c1b..a72fa287415b46b0c0da4e1e1ed75e6830d995cc 100644
--- a/boost/asio/detail/winrt_async_manager.hpp
+++ b/boost/asio/detail/winrt_async_manager.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_async_manager.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/winrt_async_op.hpp b/boost/asio/detail/winrt_async_op.hpp
index 7e158675e900bd5af8ecd7d6545aac621886a9e9..53ab671b6f4a1599f5d81cd110ab35fa37f687c6 100644
--- a/boost/asio/detail/winrt_async_op.hpp
+++ b/boost/asio/detail/winrt_async_op.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_async_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/winrt_resolve_op.hpp b/boost/asio/detail/winrt_resolve_op.hpp
index ea5c0e21eb6f50ae0d90b376a959425056862b30..1f742ba50631e928e211ff2a2b84379a106465f0 100644
--- a/boost/asio/detail/winrt_resolve_op.hpp
+++ b/boost/asio/detail/winrt_resolve_op.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_resolve_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/winrt_resolver_service.hpp b/boost/asio/detail/winrt_resolver_service.hpp
index f5c422df1b4580e112294989b874e6130d1e70f7..698e7b20a09dd8dbabde55b6a98abf6b3f65a992 100644
--- a/boost/asio/detail/winrt_resolver_service.hpp
+++ b/boost/asio/detail/winrt_resolver_service.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_resolver_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/winrt_socket_connect_op.hpp b/boost/asio/detail/winrt_socket_connect_op.hpp
index cd4d69bf560bccc0d9232b9187140738fe4ec1b0..ac2f63c52ce3f9246cee20ad3de5d5715185202e 100644
--- a/boost/asio/detail/winrt_socket_connect_op.hpp
+++ b/boost/asio/detail/winrt_socket_connect_op.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_socket_connect_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/winrt_socket_recv_op.hpp b/boost/asio/detail/winrt_socket_recv_op.hpp
index 291087bfbfedc6126148e7811e52e887ec73a90a..764590e41009f770604ae03c8f221e76f5020aef 100644
--- a/boost/asio/detail/winrt_socket_recv_op.hpp
+++ b/boost/asio/detail/winrt_socket_recv_op.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_socket_recv_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/winrt_socket_send_op.hpp b/boost/asio/detail/winrt_socket_send_op.hpp
index d2deee3aa20ee9ac44ecd0429464df784762d713..c73f92de1d0be0a5c4fbb5dd865b0a8d36a65fad 100644
--- a/boost/asio/detail/winrt_socket_send_op.hpp
+++ b/boost/asio/detail/winrt_socket_send_op.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_socket_send_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/winrt_ssocket_service.hpp b/boost/asio/detail/winrt_ssocket_service.hpp
index ffae16408d11a2053c579610bc52ed5b4cc06eb0..4f61abb98992ec1b7fe074d3fbc4c25a34a2bf99 100644
--- a/boost/asio/detail/winrt_ssocket_service.hpp
+++ b/boost/asio/detail/winrt_ssocket_service.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_ssocket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/winrt_ssocket_service_base.hpp b/boost/asio/detail/winrt_ssocket_service_base.hpp
index e6b000f3dbb0d674b73643ef90673c3e696c8586..bcfce97041fc56309f140c197de8b66c5da36c6e 100644
--- a/boost/asio/detail/winrt_ssocket_service_base.hpp
+++ b/boost/asio/detail/winrt_ssocket_service_base.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_ssocket_service_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/winrt_timer_scheduler.hpp b/boost/asio/detail/winrt_timer_scheduler.hpp
index 71a6874c1944c6e151d527c29f46e60e78c00eb3..9fc15aea3d36c8ebde2a4bdebee5a7be17e9a062 100644
--- a/boost/asio/detail/winrt_timer_scheduler.hpp
+++ b/boost/asio/detail/winrt_timer_scheduler.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_timer_scheduler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/winrt_utils.hpp b/boost/asio/detail/winrt_utils.hpp
index 0d6667860cea2e2cc1f8ef0d4159164a4df9d941..41f97baab3edf4ea0640bd016ea77de45da17a68 100644
--- a/boost/asio/detail/winrt_utils.hpp
+++ b/boost/asio/detail/winrt_utils.hpp
@@ -2,7 +2,7 @@
 // detail/winrt_utils.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/winsock_init.hpp b/boost/asio/detail/winsock_init.hpp
index 75dab5e52a256cd196acad32c02318008fc26a6d..7b81fa0d3e841dfdc7f8b39a50cef33ca97c7cd7 100644
--- a/boost/asio/detail/winsock_init.hpp
+++ b/boost/asio/detail/winsock_init.hpp
@@ -2,7 +2,7 @@
 // detail/winsock_init.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/detail/work_dispatcher.hpp b/boost/asio/detail/work_dispatcher.hpp
index 6dba3caf332c3a5fd54a1f71d11e8145120937ff..b0b142e25ffdeb71039991e09a45c23c34b5fc55 100644
--- a/boost/asio/detail/work_dispatcher.hpp
+++ b/boost/asio/detail/work_dispatcher.hpp
@@ -2,7 +2,7 @@
 // detail/work_dispatcher.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,6 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/associated_executor.hpp>
 #include <boost/asio/associated_allocator.hpp>
@@ -82,7 +83,8 @@ public:
         boost::asio::prefer(executor_,
           execution::blocking.possibly,
           execution::allocator((get_associated_allocator)(handler_))),
-        BOOST_ASIO_MOVE_CAST(Handler)(handler_));
+        boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(Handler)(handler_)));
   }
 
 private:
@@ -130,7 +132,8 @@ public:
     typename associated_allocator<Handler>::type alloc(
         (get_associated_allocator)(handler_));
     work_.get_executor().dispatch(
-        BOOST_ASIO_MOVE_CAST(Handler)(handler_), alloc);
+        boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(Handler)(handler_)), alloc);
     work_.reset();
   }
 
diff --git a/boost/asio/detail/wrapped_handler.hpp b/boost/asio/detail/wrapped_handler.hpp
index ece3a5df0bf0d5d42674242673daae742844f30a..fe402fc0d5be2586dc9f2e282302354d1f532780 100644
--- a/boost/asio/detail/wrapped_handler.hpp
+++ b/boost/asio/detail/wrapped_handler.hpp
@@ -2,7 +2,7 @@
 // detail/wrapped_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/dispatch.hpp b/boost/asio/dispatch.hpp
index 315199037623f92ff7f3e3a84baa050f5bdc2e57..0a3654577d8dcec3d7951ad7e400067853228361 100644
--- a/boost/asio/dispatch.hpp
+++ b/boost/asio/dispatch.hpp
@@ -2,7 +2,7 @@
 // dispatch.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -33,27 +33,47 @@ namespace asio {
  * executor. The function object may be called from the current thread prior to
  * returning from <tt>dispatch()</tt>. Otherwise, it is queued for execution.
  *
- * This function has the following effects:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler. The function signature of the completion handler must be:
+ * @code void handler(); @endcode
  *
- * @li Constructs a function object handler of type @c Handler, initialized
- * with <tt>handler(forward<CompletionToken>(token))</tt>.
+ * @returns This function returns <tt>async_initiate<NullaryToken,
+ * void()>(Init{}, token)</tt>, where @c Init is a function object type defined
+ * as:
  *
- * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
- * initializing the object as <tt>result(handler)</tt>.
+ * @code class Init
+ * {
+ * public:
+ *   template <typename CompletionHandler>
+ *     void operator()(CompletionHandler&& completion_handler) const;
+ * }; @endcode
  *
- * @li Obtains the handler's associated executor object @c ex by performing
- * <tt>get_associated_executor(handler)</tt>.
+ * The function call operator of @c Init:
  *
- * @li Obtains the handler's associated allocator object @c alloc by performing
- * <tt>get_associated_allocator(handler)</tt>.
- *
- * @li Performs <tt>ex.dispatch(std::move(handler), alloc)</tt>.
+ * @li Obtains the handler's associated executor object @c ex of type @c Ex by
+ * performing @code auto ex = get_associated_executor(handler); @endcode
  *
- * @li Returns <tt>result.get()</tt>.
+ * @li Obtains the handler's associated allocator object @c alloc by performing
+ * @code auto alloc = get_associated_allocator(handler); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
+ * @code execution::execute(
+ *     prefer(ex,
+ *       execution::blocking.possibly,
+ *       execution::allocator(alloc)),
+ *     std::forward<CompletionHandler>(completion_handler)); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
+ * @code ex.dispatch(
+ *     std::forward<CompletionHandler>(completion_handler),
+ *     alloc); @endcode
+ *
+ * @par Completion Signature
+ * @code void() @endcode
  */
-template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) dispatch(
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token);
+template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) dispatch(
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token);
 
 /// Submits a completion token or function object for execution.
 /**
@@ -61,36 +81,75 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) dispatch(
  * The function object may be called from the current thread prior to returning
  * from <tt>dispatch()</tt>. Otherwise, it is queued for execution.
  *
- * This function has the following effects:
- *
- * @li Constructs a function object handler of type @c Handler, initialized
- * with <tt>handler(forward<CompletionToken>(token))</tt>.
- *
- * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
- * initializing the object as <tt>result(handler)</tt>.
+ * @param ex The target executor.
  *
- * @li Obtains the handler's associated executor object @c ex1 by performing
- * <tt>get_associated_executor(handler)</tt>.
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler. The function signature of the completion handler must be:
+ * @code void handler(); @endcode
  *
- * @li Creates a work object @c w by performing <tt>make_work(ex1)</tt>.
+ * @returns This function returns <tt>async_initiate<NullaryToken,
+ * void()>(Init{ex}, token)</tt>, where @c Init is a function object type
+ * defined as:
  *
- * @li Obtains the handler's associated allocator object @c alloc by performing
- * <tt>get_associated_allocator(handler)</tt>.
+ * @code class Init
+ * {
+ * public:
+ *   using executor_type = Executor;
+ *   explicit Init(const Executor& ex) : ex_(ex) {}
+ *   executor_type get_executor() const noexcept { return ex_; }
+ *   template <typename CompletionHandler>
+ *     void operator()(CompletionHandler&& completion_handler) const;
+ * private:
+ *   Executor ex_; // exposition only
+ * }; @endcode
  *
- * @li Constructs a function object @c f with a function call operator that
- * performs <tt>ex1.dispatch(std::move(handler), alloc)</tt> followed by
- * <tt>w.reset()</tt>.
+ * The function call operator of @c Init:
  *
- * @li Performs <tt>Executor(ex).dispatch(std::move(f), alloc)</tt>.
+ * @li Obtains the handler's associated executor object @c ex1 of type @c Ex1 by
+ * performing @code auto ex1 = get_associated_executor(handler, ex); @endcode
  *
- * @li Returns <tt>result.get()</tt>.
+ * @li Obtains the handler's associated allocator object @c alloc by performing
+ * @code auto alloc = get_associated_allocator(handler); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex1>::value</tt> is true, constructs a
+ * function object @c f with a member @c executor_ that is initialised with
+ * <tt>prefer(ex1, execution::outstanding_work.tracked)</tt>, a member @c
+ * handler_ that is a decay-copy of @c completion_handler, and a function call
+ * operator that performs:
+ * @code auto a = get_associated_allocator(handler_);
+ * execution::execute(
+ *     prefer(executor_,
+ *       execution::blocking.possibly,
+ *       execution::allocator(a)),
+ *     std::move(handler_)); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex1>::value</tt> is false, constructs a
+ * function object @c f with a member @c work_ that is initialised with
+ * <tt>make_work_guard(ex1)</tt>, a member @c handler_ that is a decay-copy of
+ * @c completion_handler, and a function call operator that performs:
+ * @code auto a = get_associated_allocator(handler_);
+ * work_.get_executor().dispatch(std::move(handler_), a);
+ * work_.reset(); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
+ * @code execution::execute(
+ *     prefer(ex,
+ *       execution::blocking.possibly,
+ *       execution::allocator(alloc)),
+ *     std::move(f)); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
+ * @code ex.dispatch(std::move(f), alloc); @endcode
+ *
+ * @par Completion Signature
+ * @code void() @endcode
  */
 template <typename Executor,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) dispatch(
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) dispatch(
     const Executor& ex,
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
     typename constraint<
       execution::is_executor<Executor>::value || is_executor<Executor>::value
@@ -98,16 +157,25 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) dispatch(
 
 /// Submits a completion token or function object for execution.
 /**
+ * @param ctx An execution context, from which the target executor is obtained.
+ *
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler. The function signature of the completion handler must be:
+ * @code void handler(); @endcode
+ *
  * @returns <tt>dispatch(ctx.get_executor(),
- * forward<CompletionToken>(token))</tt>.
+ * forward<NullaryToken>(token))</tt>.
+ *
+ * @par Completion Signature
+ * @code void() @endcode
  */
 template <typename ExecutionContext,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
         typename ExecutionContext::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) dispatch(
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) dispatch(
     ExecutionContext& ctx,
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename ExecutionContext::executor_type),
     typename constraint<is_convertible<
diff --git a/boost/asio/error.hpp b/boost/asio/error.hpp
index 7481c731633797db96cb0eb01a0abd666ca91dbc..11a1ce30cfb68b1b7d86b1b45a87420835df2df8 100644
--- a/boost/asio/error.hpp
+++ b/boost/asio/error.hpp
@@ -2,7 +2,7 @@
 // error.hpp
 // ~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution.hpp b/boost/asio/execution.hpp
index b44182728d059e586734a5f8b0e885566ce39f84..e8ce4e8e92f881a33d0b3b3f455152ab4bbfae02 100644
--- a/boost/asio/execution.hpp
+++ b/boost/asio/execution.hpp
@@ -2,7 +2,7 @@
 // execution.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/allocator.hpp b/boost/asio/execution/allocator.hpp
index fe1c6f8198efa83876c0af50db62dc47fdca3736..47f2f434d9867e7d309a49b296b6e04ef25602ad 100644
--- a/boost/asio/execution/allocator.hpp
+++ b/boost/asio/execution/allocator.hpp
@@ -2,7 +2,7 @@
 // execution/allocator.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/any_executor.hpp b/boost/asio/execution/any_executor.hpp
index da5991a81b181dd32bf1237bc0f7ae7045392a29..1a066d247897370ae79945d3c67b1176da2a195e 100644
--- a/boost/asio/execution/any_executor.hpp
+++ b/boost/asio/execution/any_executor.hpp
@@ -2,7 +2,7 @@
 // execution/any_executor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -482,6 +482,11 @@ struct is_valid_target_executor :
 {
 };
 
+template <typename Props>
+struct is_valid_target_executor<int, Props> : false_type
+{
+};
+
 class any_executor_base
 {
 public:
@@ -1163,7 +1168,7 @@ private:
 //  template <typename...> friend class any_executor;
 
   typedef aligned_storage<
-      sizeof(boost::asio::detail::shared_ptr<void>),
+      sizeof(boost::asio::detail::shared_ptr<void>) + sizeof(void*),
       alignment_of<boost::asio::detail::shared_ptr<void> >::value
     >::type object_type;
 
@@ -1307,8 +1312,8 @@ public:
 
   template <typename AnyExecutor1, typename AnyExecutor2>
   friend typename enable_if<
-    is_same<AnyExecutor1, any_executor>::value
-      || is_same<AnyExecutor2, any_executor>::value,
+    is_base_of<any_executor, AnyExecutor1>::value
+      || is_base_of<any_executor, AnyExecutor2>::value,
     bool
   >::type operator==(const AnyExecutor1& a,
       const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT
@@ -1336,8 +1341,8 @@ public:
 
   template <typename AnyExecutor1, typename AnyExecutor2>
   friend typename enable_if<
-    is_same<AnyExecutor1, any_executor>::value
-      || is_same<AnyExecutor2, any_executor>::value,
+    is_base_of<any_executor, AnyExecutor1>::value
+      || is_base_of<any_executor, AnyExecutor2>::value,
     bool
   >::type operator!=(const AnyExecutor1& a,
       const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT
@@ -1504,8 +1509,8 @@ public:
 
   template <typename AnyExecutor1, typename AnyExecutor2>
   friend typename enable_if<
-    is_same<AnyExecutor1, any_executor>::value
-      || is_same<AnyExecutor2, any_executor>::value,
+    is_base_of<any_executor, AnyExecutor1>::value
+      || is_base_of<any_executor, AnyExecutor2>::value,
     bool
   >::type operator==(const AnyExecutor1& a,
       const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT
@@ -1533,8 +1538,8 @@ public:
 
   template <typename AnyExecutor1, typename AnyExecutor2>
   friend typename enable_if<
-    is_same<AnyExecutor1, any_executor>::value
-      || is_same<AnyExecutor2, any_executor>::value,
+    is_base_of<any_executor, AnyExecutor1>::value
+      || is_base_of<any_executor, AnyExecutor2>::value,
     bool
   >::type operator!=(const AnyExecutor1& a,
       const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT
@@ -1919,8 +1924,8 @@ inline void swap(any_executor<SupportableProperties...>& a,
     \
     template <typename AnyExecutor1, typename AnyExecutor2> \
     friend typename enable_if< \
-      is_same<AnyExecutor1, any_executor>::value \
-        || is_same<AnyExecutor2, any_executor>::value, \
+      is_base_of<any_executor, AnyExecutor1>::value \
+        || is_base_of<any_executor, AnyExecutor2>::value, \
       bool \
     >::type operator==(const AnyExecutor1& a, \
         const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT \
@@ -1948,8 +1953,8 @@ inline void swap(any_executor<SupportableProperties...>& a,
     \
     template <typename AnyExecutor1, typename AnyExecutor2> \
     friend typename enable_if< \
-      is_same<AnyExecutor1, any_executor>::value \
-        || is_same<AnyExecutor2, any_executor>::value, \
+      is_base_of<any_executor, AnyExecutor1>::value \
+        || is_base_of<any_executor, AnyExecutor2>::value, \
       bool \
     >::type operator!=(const AnyExecutor1& a, \
         const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT \
diff --git a/boost/asio/execution/bad_executor.hpp b/boost/asio/execution/bad_executor.hpp
index 9fa399091ac9688f2c861369e3c7c3443e1727da..25ba0782fcedf9b91bc23fb7f4602b5b037d3fc4 100644
--- a/boost/asio/execution/bad_executor.hpp
+++ b/boost/asio/execution/bad_executor.hpp
@@ -2,7 +2,7 @@
 // execution/bad_executor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/blocking.hpp b/boost/asio/execution/blocking.hpp
index b261937c74f5b3bb27122f2783ab5a922a72825a..b4eb733f55efaaa1d049099e7eeffabfe5d0cb23 100644
--- a/boost/asio/execution/blocking.hpp
+++ b/boost/asio/execution/blocking.hpp
@@ -2,7 +2,7 @@
 // execution/blocking.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/blocking_adaptation.hpp b/boost/asio/execution/blocking_adaptation.hpp
index d13f9322b3cd8afe984b4d1ddddb447f15600606..69101a0fb0e8eeee8689d8c7a7618cee1ee48a71 100644
--- a/boost/asio/execution/blocking_adaptation.hpp
+++ b/boost/asio/execution/blocking_adaptation.hpp
@@ -2,7 +2,7 @@
 // execution/blocking_adaptation.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/bulk_execute.hpp b/boost/asio/execution/bulk_execute.hpp
index 2979822e25c8fc10e4a121fc5e94555781bbf890..4c77558809773280df9beeab29f5d95c08598241 100644
--- a/boost/asio/execution/bulk_execute.hpp
+++ b/boost/asio/execution/bulk_execute.hpp
@@ -2,7 +2,7 @@
 // execution/bulk_execute.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -100,7 +100,7 @@ struct can_bulk_execute :
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_execution_bulk_execute_fn {
+namespace boost_asio_execution_bulk_execute_fn {
 
 using boost::asio::declval;
 using boost::asio::enable_if;
@@ -339,23 +339,24 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_execution_bulk_execute_fn
+} // namespace boost_asio_execution_bulk_execute_fn
 namespace boost {
 namespace asio {
 namespace execution {
 namespace {
 
 static BOOST_ASIO_CONSTEXPR
-  const asio_execution_bulk_execute_fn::impl& bulk_execute =
-    asio_execution_bulk_execute_fn::static_instance<>::instance;
+  const boost_asio_execution_bulk_execute_fn::impl& bulk_execute =
+    boost_asio_execution_bulk_execute_fn::static_instance<>::instance;
 
 } // namespace
 
 template <typename S, typename F, typename N>
 struct can_bulk_execute :
   integral_constant<bool,
-    asio_execution_bulk_execute_fn::call_traits<S, void(F, N)>::overload !=
-      asio_execution_bulk_execute_fn::ill_formed>
+    boost_asio_execution_bulk_execute_fn::call_traits<
+      S, void(F, N)>::overload !=
+        boost_asio_execution_bulk_execute_fn::ill_formed>
 {
 };
 
@@ -369,7 +370,8 @@ constexpr bool can_bulk_execute_v = can_bulk_execute<S, F, N>::value;
 template <typename S, typename F, typename N>
 struct is_nothrow_bulk_execute :
   integral_constant<bool,
-    asio_execution_bulk_execute_fn::call_traits<S, void(F, N)>::is_noexcept>
+    boost_asio_execution_bulk_execute_fn::call_traits<
+      S, void(F, N)>::is_noexcept>
 {
 };
 
@@ -384,7 +386,7 @@ constexpr bool is_nothrow_bulk_execute_v
 template <typename S, typename F, typename N>
 struct bulk_execute_result
 {
-  typedef typename asio_execution_bulk_execute_fn::call_traits<
+  typedef typename boost_asio_execution_bulk_execute_fn::call_traits<
       S, void(F, N)>::result_type type;
 };
 
diff --git a/boost/asio/execution/bulk_guarantee.hpp b/boost/asio/execution/bulk_guarantee.hpp
index b5f638ba256201f89b2d82a38c7a490f8dafb878..be2539b7f3a7a9cede88280bddac5a4c3279a3bf 100644
--- a/boost/asio/execution/bulk_guarantee.hpp
+++ b/boost/asio/execution/bulk_guarantee.hpp
@@ -2,7 +2,7 @@
 // execution/bulk_guarantee.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/connect.hpp b/boost/asio/execution/connect.hpp
index efaabee23954de6a076d1592149efc46cbaf8924..9ee5655a769740a2b94929148b15f46d52b9a722 100644
--- a/boost/asio/execution/connect.hpp
+++ b/boost/asio/execution/connect.hpp
@@ -2,7 +2,7 @@
 // execution/connect.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -132,7 +132,7 @@ using connect_result_t = typename connect_result<S, R>::type;
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_execution_connect_fn {
+namespace boost_asio_execution_connect_fn {
 
 using boost::asio::conditional;
 using boost::asio::declval;
@@ -427,22 +427,22 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_execution_connect_fn
+} // namespace boost_asio_execution_connect_fn
 namespace boost {
 namespace asio {
 namespace execution {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_execution_connect_fn::impl&
-  connect = asio_execution_connect_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_execution_connect_fn::impl&
+  connect = boost_asio_execution_connect_fn::static_instance<>::instance;
 
 } // namespace
 
 template <typename S, typename R>
 struct can_connect :
   integral_constant<bool,
-    asio_execution_connect_fn::call_traits<S, void(R)>::overload !=
-      asio_execution_connect_fn::ill_formed>
+    boost_asio_execution_connect_fn::call_traits<S, void(R)>::overload !=
+      boost_asio_execution_connect_fn::ill_formed>
 {
 };
 
@@ -456,7 +456,7 @@ constexpr bool can_connect_v = can_connect<S, R>::value;
 template <typename S, typename R>
 struct is_nothrow_connect :
   integral_constant<bool,
-    asio_execution_connect_fn::call_traits<S, void(R)>::is_noexcept>
+    boost_asio_execution_connect_fn::call_traits<S, void(R)>::is_noexcept>
 {
 };
 
@@ -471,7 +471,7 @@ constexpr bool is_nothrow_connect_v
 template <typename S, typename R>
 struct connect_result
 {
-  typedef typename asio_execution_connect_fn::call_traits<
+  typedef typename boost_asio_execution_connect_fn::call_traits<
       S, void(R)>::result_type type;
 };
 
diff --git a/boost/asio/execution/context.hpp b/boost/asio/execution/context.hpp
index e429ebc003e44901c821b4b854d1e4497fd6985b..5ad3db13ec8c7114a2a69165de98d34232fae274 100644
--- a/boost/asio/execution/context.hpp
+++ b/boost/asio/execution/context.hpp
@@ -2,7 +2,7 @@
 // execution/context.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/context_as.hpp b/boost/asio/execution/context_as.hpp
index eec57763f65fea6a4168d7c9aec1b6e2c2779263..0de337ba83e5e7f89027d70bb3919c19b3311bf0 100644
--- a/boost/asio/execution/context_as.hpp
+++ b/boost/asio/execution/context_as.hpp
@@ -2,7 +2,7 @@
 // execution/context_as.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/detail/as_invocable.hpp b/boost/asio/execution/detail/as_invocable.hpp
index b262d5faa0aae6f52941cfddca086779419d4657..b6aa9a57ca8ca0bc22b46f71076b28b32817f8a3 100644
--- a/boost/asio/execution/detail/as_invocable.hpp
+++ b/boost/asio/execution/detail/as_invocable.hpp
@@ -2,7 +2,7 @@
 // execution/detail/as_invocable.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/detail/as_operation.hpp b/boost/asio/execution/detail/as_operation.hpp
index 7a0796ba61b4363440358ae911bc25b746b1edf3..94b1ab1382ac5505b1f550b6f9f59537ac30ac85 100644
--- a/boost/asio/execution/detail/as_operation.hpp
+++ b/boost/asio/execution/detail/as_operation.hpp
@@ -2,7 +2,7 @@
 // execution/detail/as_operation.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/detail/as_receiver.hpp b/boost/asio/execution/detail/as_receiver.hpp
index 114b2d02e201e35d6a7fe77f688537a2c82cba1f..330a0ba82d5555e8057d7109fa05376ed113ed0f 100644
--- a/boost/asio/execution/detail/as_receiver.hpp
+++ b/boost/asio/execution/detail/as_receiver.hpp
@@ -2,7 +2,7 @@
 // execution/detail/as_receiver.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/detail/bulk_sender.hpp b/boost/asio/execution/detail/bulk_sender.hpp
index 104dc9451d326cebdaad054283504d408d068ac6..407c86467ec669fc0b39f5fee64710376caeea73 100644
--- a/boost/asio/execution/detail/bulk_sender.hpp
+++ b/boost/asio/execution/detail/bulk_sender.hpp
@@ -2,7 +2,7 @@
 // execution/detail/bulk_sender.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/detail/submit_receiver.hpp b/boost/asio/execution/detail/submit_receiver.hpp
index dddac5857f1eb999a78be4486c957357bffcc6e9..d784f6c8efc6e7b8c96cc115d36f0e675ae4c564 100644
--- a/boost/asio/execution/detail/submit_receiver.hpp
+++ b/boost/asio/execution/detail/submit_receiver.hpp
@@ -2,7 +2,7 @@
 // execution/detail/submit_receiver.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/detail/void_receiver.hpp b/boost/asio/execution/detail/void_receiver.hpp
index 09581372282f4b844001b555617af82de0c9f3af..c40368dff2432e4c402f1ee9ec0ef6363e2489ff 100644
--- a/boost/asio/execution/detail/void_receiver.hpp
+++ b/boost/asio/execution/detail/void_receiver.hpp
@@ -2,7 +2,7 @@
 // execution/detail/void_receiver.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/execute.hpp b/boost/asio/execution/execute.hpp
index 3c42ce22e01666c260e537a37397ef0d170c3375..0a9ea99bf321113c86382dc4c0c87db113b78162 100644
--- a/boost/asio/execution/execute.hpp
+++ b/boost/asio/execution/execute.hpp
@@ -2,7 +2,7 @@
 // execution/execute.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -88,7 +88,7 @@ void submit_helper(BOOST_ASIO_MOVE_ARG(S) s, BOOST_ASIO_MOVE_ARG(R) r);
 } // namespace execution
 } // namespace asio
 } // namespace boost
-namespace asio_execution_execute_fn {
+namespace boost_asio_execution_execute_fn {
 
 using boost::asio::conditional;
 using boost::asio::decay;
@@ -249,25 +249,25 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_execution_execute_fn
+} // namespace boost_asio_execution_execute_fn
 namespace boost {
 namespace asio {
 namespace execution {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_execution_execute_fn::impl&
-  execute = asio_execution_execute_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_execution_execute_fn::impl&
+  execute = boost_asio_execution_execute_fn::static_instance<>::instance;
 
 } // namespace
 
-typedef asio_execution_execute_fn::impl execute_t;
+typedef boost_asio_execution_execute_fn::impl execute_t;
 
 template <typename T, typename F>
 struct can_execute :
   integral_constant<bool,
-    asio_execution_execute_fn::call_traits<
+    boost_asio_execution_execute_fn::call_traits<
       execute_t, T, void(F)>::overload !=
-        asio_execution_execute_fn::ill_formed>
+        boost_asio_execution_execute_fn::ill_formed>
 {
 };
 
diff --git a/boost/asio/execution/executor.hpp b/boost/asio/execution/executor.hpp
index b1d8bf0ed8ecad2440a02e2bad149497521327d4..b9f766b4b9a5980544fa439d97e4b5d059c30643 100644
--- a/boost/asio/execution/executor.hpp
+++ b/boost/asio/execution/executor.hpp
@@ -2,7 +2,7 @@
 // execution/executor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/impl/bad_executor.ipp b/boost/asio/execution/impl/bad_executor.ipp
index 9b76cc11913af0cc392e75df74fb55e46cd715bf..bb13acadd2758f0220a35b4951fa0dd9ceef7fb8 100644
--- a/boost/asio/execution/impl/bad_executor.ipp
+++ b/boost/asio/execution/impl/bad_executor.ipp
@@ -2,7 +2,7 @@
 // exection/impl/bad_executor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/impl/receiver_invocation_error.ipp b/boost/asio/execution/impl/receiver_invocation_error.ipp
index c6ebb70d4a1fb3616783c6f617f66c7c0f1a511c..04387e723a935d06ad9009d2f36e35f6961a1f02 100644
--- a/boost/asio/execution/impl/receiver_invocation_error.ipp
+++ b/boost/asio/execution/impl/receiver_invocation_error.ipp
@@ -2,7 +2,7 @@
 // exection/impl/receiver_invocation_error.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/invocable_archetype.hpp b/boost/asio/execution/invocable_archetype.hpp
index 49edebaec155c2f06a2d8beb78025468125a9d00..bf60c39946116a75b9142ef1748cf83d1c402c0e 100644
--- a/boost/asio/execution/invocable_archetype.hpp
+++ b/boost/asio/execution/invocable_archetype.hpp
@@ -2,7 +2,7 @@
 // execution/invocable_archetype.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/mapping.hpp b/boost/asio/execution/mapping.hpp
index 2b102401b400e8755e25b37e7b40f595f99c015d..b46ddfab739d8a36b42642faebba19dff484b8c0 100644
--- a/boost/asio/execution/mapping.hpp
+++ b/boost/asio/execution/mapping.hpp
@@ -2,7 +2,7 @@
 // execution/mapping.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/occupancy.hpp b/boost/asio/execution/occupancy.hpp
index f9b12334d6aac42e231779d6c8143dc4af587dd0..4716b5259ec9cee9e31eaf3488b8ad6f4e3235a1 100644
--- a/boost/asio/execution/occupancy.hpp
+++ b/boost/asio/execution/occupancy.hpp
@@ -2,7 +2,7 @@
 // execution/occupancy.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/operation_state.hpp b/boost/asio/execution/operation_state.hpp
index 26964c479198108263ce20d85fe5480e8c06c44e..2d4b914069575bd72744931c84cfb97ba0e0df97 100644
--- a/boost/asio/execution/operation_state.hpp
+++ b/boost/asio/execution/operation_state.hpp
@@ -2,7 +2,7 @@
 // execution/operation_state.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/outstanding_work.hpp b/boost/asio/execution/outstanding_work.hpp
index ef25c60079fe099e372973363af3dc3923e36bff..eb8e342f3e8565136d669eb637e4f7c76f5b4775 100644
--- a/boost/asio/execution/outstanding_work.hpp
+++ b/boost/asio/execution/outstanding_work.hpp
@@ -2,7 +2,7 @@
 // execution/outstanding_work.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/prefer_only.hpp b/boost/asio/execution/prefer_only.hpp
index d0e8fc83c7b72c5886428d66e60726c73fff3634..8f22b5b85349ae41948d266bb18c16c8e89e03e6 100644
--- a/boost/asio/execution/prefer_only.hpp
+++ b/boost/asio/execution/prefer_only.hpp
@@ -2,7 +2,7 @@
 // execution/prefer_only.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/receiver.hpp b/boost/asio/execution/receiver.hpp
index 80d78fc7235f97cff5500093150b1cab262511c1..e51a04c13d5c00749eabdfbda785f5dfbdc4f07c 100644
--- a/boost/asio/execution/receiver.hpp
+++ b/boost/asio/execution/receiver.hpp
@@ -2,7 +2,7 @@
 // execution/receiver.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/receiver_invocation_error.hpp b/boost/asio/execution/receiver_invocation_error.hpp
index 2d3d6a29ce0fac5052ce1233db155018da2ea37e..0b4be6b84cee7b6940fc1be391ff122a4339cee1 100644
--- a/boost/asio/execution/receiver_invocation_error.hpp
+++ b/boost/asio/execution/receiver_invocation_error.hpp
@@ -2,7 +2,7 @@
 // execution/receiver_invocation_error.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/relationship.hpp b/boost/asio/execution/relationship.hpp
index bc8d014f1ab9fced6205d61a0b14e62777a9577f..161a5d92edfca33a7faceb29338f33ab4d4a8e14 100644
--- a/boost/asio/execution/relationship.hpp
+++ b/boost/asio/execution/relationship.hpp
@@ -2,7 +2,7 @@
 // execution/relationship.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/schedule.hpp b/boost/asio/execution/schedule.hpp
index acb95465b4f086ac4a3ac8742508de21b959d78a..c86e7fab7eeee7e8a55c5feb2c3a0ad62470f009 100644
--- a/boost/asio/execution/schedule.hpp
+++ b/boost/asio/execution/schedule.hpp
@@ -2,7 +2,7 @@
 // execution/schedule.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -69,7 +69,7 @@ struct can_schedule :
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_execution_schedule_fn {
+namespace boost_asio_execution_schedule_fn {
 
 using boost::asio::decay;
 using boost::asio::declval;
@@ -239,22 +239,22 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_execution_schedule_fn
+} // namespace boost_asio_execution_schedule_fn
 namespace boost {
 namespace asio {
 namespace execution {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_execution_schedule_fn::impl&
-  schedule = asio_execution_schedule_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_execution_schedule_fn::impl&
+  schedule = boost_asio_execution_schedule_fn::static_instance<>::instance;
 
 } // namespace
 
 template <typename S>
 struct can_schedule :
   integral_constant<bool,
-    asio_execution_schedule_fn::call_traits<S>::overload !=
-      asio_execution_schedule_fn::ill_formed>
+    boost_asio_execution_schedule_fn::call_traits<S>::overload !=
+      boost_asio_execution_schedule_fn::ill_formed>
 {
 };
 
@@ -268,7 +268,7 @@ constexpr bool can_schedule_v = can_schedule<S>::value;
 template <typename S>
 struct is_nothrow_schedule :
   integral_constant<bool,
-    asio_execution_schedule_fn::call_traits<S>::is_noexcept>
+    boost_asio_execution_schedule_fn::call_traits<S>::is_noexcept>
 {
 };
 
diff --git a/boost/asio/execution/scheduler.hpp b/boost/asio/execution/scheduler.hpp
index 984b8200d583498459db708e68efef08f7574bd2..9856d0e9cdd6bad79cadfc5d2133c16d971dcbbd 100644
--- a/boost/asio/execution/scheduler.hpp
+++ b/boost/asio/execution/scheduler.hpp
@@ -2,7 +2,7 @@
 // execution/scheduler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/sender.hpp b/boost/asio/execution/sender.hpp
index ba7f4d2c48e7f4bf0f41af6b15a92f42ee4a4517..011c04f2265b8670353e0c4d6a60a517505f7ad1 100644
--- a/boost/asio/execution/sender.hpp
+++ b/boost/asio/execution/sender.hpp
@@ -2,7 +2,7 @@
 // execution/sender.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/execution/set_done.hpp b/boost/asio/execution/set_done.hpp
index 28f2206ed4c21b008cf2c6a9df2a68a20fde272c..799a358e8e3113b01edeac558507c2ebde6a148b 100644
--- a/boost/asio/execution/set_done.hpp
+++ b/boost/asio/execution/set_done.hpp
@@ -2,7 +2,7 @@
 // execution/set_done.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -68,7 +68,7 @@ struct can_set_done :
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_execution_set_done_fn {
+namespace boost_asio_execution_set_done_fn {
 
 using boost::asio::decay;
 using boost::asio::declval;
@@ -202,22 +202,22 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_execution_set_done_fn
+} // namespace boost_asio_execution_set_done_fn
 namespace boost {
 namespace asio {
 namespace execution {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_execution_set_done_fn::impl&
-  set_done = asio_execution_set_done_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_execution_set_done_fn::impl&
+  set_done = boost_asio_execution_set_done_fn::static_instance<>::instance;
 
 } // namespace
 
 template <typename R>
 struct can_set_done :
   integral_constant<bool,
-    asio_execution_set_done_fn::call_traits<R>::overload !=
-      asio_execution_set_done_fn::ill_formed>
+    boost_asio_execution_set_done_fn::call_traits<R>::overload !=
+      boost_asio_execution_set_done_fn::ill_formed>
 {
 };
 
@@ -231,7 +231,7 @@ constexpr bool can_set_done_v = can_set_done<R>::value;
 template <typename R>
 struct is_nothrow_set_done :
   integral_constant<bool,
-    asio_execution_set_done_fn::call_traits<R>::is_noexcept>
+    boost_asio_execution_set_done_fn::call_traits<R>::is_noexcept>
 {
 };
 
diff --git a/boost/asio/execution/set_error.hpp b/boost/asio/execution/set_error.hpp
index 94d0b73c9cd8e9cac335967b1cbe3ff08994edde..3347fff34ab8eae7f27413b9d7aed42d0c16c22b 100644
--- a/boost/asio/execution/set_error.hpp
+++ b/boost/asio/execution/set_error.hpp
@@ -2,7 +2,7 @@
 // execution/set_error.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -68,7 +68,7 @@ struct can_set_error :
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_execution_set_error_fn {
+namespace boost_asio_execution_set_error_fn {
 
 using boost::asio::decay;
 using boost::asio::declval;
@@ -202,22 +202,22 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_execution_set_error_fn
+} // namespace boost_asio_execution_set_error_fn
 namespace boost {
 namespace asio {
 namespace execution {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_execution_set_error_fn::impl&
-  set_error = asio_execution_set_error_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_execution_set_error_fn::impl&
+  set_error = boost_asio_execution_set_error_fn::static_instance<>::instance;
 
 } // namespace
 
 template <typename R, typename E>
 struct can_set_error :
   integral_constant<bool,
-    asio_execution_set_error_fn::call_traits<R, void(E)>::overload !=
-      asio_execution_set_error_fn::ill_formed>
+    boost_asio_execution_set_error_fn::call_traits<R, void(E)>::overload !=
+      boost_asio_execution_set_error_fn::ill_formed>
 {
 };
 
@@ -231,7 +231,7 @@ constexpr bool can_set_error_v = can_set_error<R, E>::value;
 template <typename R, typename E>
 struct is_nothrow_set_error :
   integral_constant<bool,
-    asio_execution_set_error_fn::call_traits<R, void(E)>::is_noexcept>
+    boost_asio_execution_set_error_fn::call_traits<R, void(E)>::is_noexcept>
 {
 };
 
diff --git a/boost/asio/execution/set_value.hpp b/boost/asio/execution/set_value.hpp
index b313f075147e8bf3c7174cde2bad86c1ac25ba41..0deb1d381bc13b324133aad0b0cc4317e734a928 100644
--- a/boost/asio/execution/set_value.hpp
+++ b/boost/asio/execution/set_value.hpp
@@ -2,7 +2,7 @@
 // execution/set_value.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -71,7 +71,7 @@ struct can_set_value :
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_execution_set_value_fn {
+namespace boost_asio_execution_set_value_fn {
 
 using boost::asio::decay;
 using boost::asio::declval;
@@ -383,14 +383,14 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_execution_set_value_fn
+} // namespace boost_asio_execution_set_value_fn
 namespace boost {
 namespace asio {
 namespace execution {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_execution_set_value_fn::impl&
-  set_value = asio_execution_set_value_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_execution_set_value_fn::impl&
+  set_value = boost_asio_execution_set_value_fn::static_instance<>::instance;
 
 } // namespace
 
@@ -399,8 +399,8 @@ static BOOST_ASIO_CONSTEXPR const asio_execution_set_value_fn::impl&
 template <typename R, typename... Vs>
 struct can_set_value :
   integral_constant<bool,
-    asio_execution_set_value_fn::call_traits<R, void(Vs...)>::overload !=
-      asio_execution_set_value_fn::ill_formed>
+    boost_asio_execution_set_value_fn::call_traits<R, void(Vs...)>::overload !=
+      boost_asio_execution_set_value_fn::ill_formed>
 {
 };
 
@@ -414,7 +414,7 @@ constexpr bool can_set_value_v = can_set_value<R, Vs...>::value;
 template <typename R, typename... Vs>
 struct is_nothrow_set_value :
   integral_constant<bool,
-    asio_execution_set_value_fn::call_traits<R, void(Vs...)>::is_noexcept>
+    boost_asio_execution_set_value_fn::call_traits<R, void(Vs...)>::is_noexcept>
 {
 };
 
@@ -441,15 +441,15 @@ struct is_nothrow_set_value;
 template <typename R>
 struct can_set_value<R> :
   integral_constant<bool,
-    asio_execution_set_value_fn::call_traits<R, void()>::overload !=
-      asio_execution_set_value_fn::ill_formed>
+    boost_asio_execution_set_value_fn::call_traits<R, void()>::overload !=
+      boost_asio_execution_set_value_fn::ill_formed>
 {
 };
 
 template <typename R>
 struct is_nothrow_set_value<R> :
   integral_constant<bool,
-    asio_execution_set_value_fn::call_traits<R, void()>::is_noexcept>
+    boost_asio_execution_set_value_fn::call_traits<R, void()>::is_noexcept>
 {
 };
 
@@ -457,16 +457,16 @@ struct is_nothrow_set_value<R> :
   template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
   struct can_set_value<R, BOOST_ASIO_VARIADIC_TARGS(n)> : \
     integral_constant<bool, \
-      asio_execution_set_value_fn::call_traits<R, \
+      boost_asio_execution_set_value_fn::call_traits<R, \
         void(BOOST_ASIO_VARIADIC_TARGS(n))>::overload != \
-          asio_execution_set_value_fn::ill_formed> \
+          boost_asio_execution_set_value_fn::ill_formed> \
   { \
   }; \
   \
   template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
   struct is_nothrow_set_value<R, BOOST_ASIO_VARIADIC_TARGS(n)> : \
     integral_constant<bool, \
-      asio_execution_set_value_fn::call_traits<R, \
+      boost_asio_execution_set_value_fn::call_traits<R, \
         void(BOOST_ASIO_VARIADIC_TARGS(n))>::is_noexcept> \
   { \
   }; \
diff --git a/boost/asio/execution/start.hpp b/boost/asio/execution/start.hpp
index 6ea0ee0e8e73d3b23768ae2aee703e42ac4d7cbe..f87001b6835f4b4de76764978f1ac70c1998489d 100644
--- a/boost/asio/execution/start.hpp
+++ b/boost/asio/execution/start.hpp
@@ -2,7 +2,7 @@
 // execution/start.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -65,7 +65,7 @@ struct can_start :
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_execution_start_fn {
+namespace boost_asio_execution_start_fn {
 
 using boost::asio::decay;
 using boost::asio::declval;
@@ -199,22 +199,22 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_execution_start_fn
+} // namespace boost_asio_execution_start_fn
 namespace boost {
 namespace asio {
 namespace execution {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_execution_start_fn::impl&
-  start = asio_execution_start_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_execution_start_fn::impl&
+  start = boost_asio_execution_start_fn::static_instance<>::instance;
 
 } // namespace
 
 template <typename R>
 struct can_start :
   integral_constant<bool,
-    asio_execution_start_fn::call_traits<R>::overload !=
-      asio_execution_start_fn::ill_formed>
+    boost_asio_execution_start_fn::call_traits<R>::overload !=
+      boost_asio_execution_start_fn::ill_formed>
 {
 };
 
@@ -228,7 +228,7 @@ constexpr bool can_start_v = can_start<R>::value;
 template <typename R>
 struct is_nothrow_start :
   integral_constant<bool,
-    asio_execution_start_fn::call_traits<R>::is_noexcept>
+    boost_asio_execution_start_fn::call_traits<R>::is_noexcept>
 {
 };
 
diff --git a/boost/asio/execution/submit.hpp b/boost/asio/execution/submit.hpp
index da29e71eb537d6aaf92988154b009e63260de6c0..ee8002c45659da868501068c48a3273c09d1362c 100644
--- a/boost/asio/execution/submit.hpp
+++ b/boost/asio/execution/submit.hpp
@@ -2,7 +2,7 @@
 // execution/submit.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -109,7 +109,7 @@ struct can_submit :
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_execution_submit_fn {
+namespace boost_asio_execution_submit_fn {
 
 using boost::asio::declval;
 using boost::asio::enable_if;
@@ -386,22 +386,22 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_execution_submit_fn
+} // namespace boost_asio_execution_submit_fn
 namespace boost {
 namespace asio {
 namespace execution {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_execution_submit_fn::impl&
-  submit = asio_execution_submit_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_execution_submit_fn::impl&
+  submit = boost_asio_execution_submit_fn::static_instance<>::instance;
 
 } // namespace
 
 template <typename S, typename R>
 struct can_submit :
   integral_constant<bool,
-    asio_execution_submit_fn::call_traits<S, void(R)>::overload !=
-      asio_execution_submit_fn::ill_formed>
+    boost_asio_execution_submit_fn::call_traits<S, void(R)>::overload !=
+      boost_asio_execution_submit_fn::ill_formed>
 {
 };
 
@@ -415,7 +415,7 @@ constexpr bool can_submit_v = can_submit<S, R>::value;
 template <typename S, typename R>
 struct is_nothrow_submit :
   integral_constant<bool,
-    asio_execution_submit_fn::call_traits<S, void(R)>::is_noexcept>
+    boost_asio_execution_submit_fn::call_traits<S, void(R)>::is_noexcept>
 {
 };
 
@@ -430,7 +430,7 @@ constexpr bool is_nothrow_submit_v
 template <typename S, typename R>
 struct submit_result
 {
-  typedef typename asio_execution_submit_fn::call_traits<
+  typedef typename boost_asio_execution_submit_fn::call_traits<
       S, void(R)>::result_type type;
 };
 
diff --git a/boost/asio/execution_context.hpp b/boost/asio/execution_context.hpp
index 4e73b6163252ffdf75930e67eac5ba39d5fc0a1e..e305dba5d80c315713169656285b633028c469c2 100644
--- a/boost/asio/execution_context.hpp
+++ b/boost/asio/execution_context.hpp
@@ -2,7 +2,7 @@
 // execution_context.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/executor.hpp b/boost/asio/executor.hpp
index 77437726d4a7d99731d9a8cdaa672dbcc2945d7b..7ef34081e30e1391e97de44d3c7e30764e3638a0 100644
--- a/boost/asio/executor.hpp
+++ b/boost/asio/executor.hpp
@@ -2,7 +2,7 @@
 // executor.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/executor_work_guard.hpp b/boost/asio/executor_work_guard.hpp
index 5811f36934134ab68eeff9bf7dbe59d6ece14dd9..aabac6c5aafd933bd133254374154623d1b561d0 100644
--- a/boost/asio/executor_work_guard.hpp
+++ b/boost/asio/executor_work_guard.hpp
@@ -2,7 +2,7 @@
 // executor_work_guard.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,8 +17,6 @@
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
-
 #include <boost/asio/associated_executor.hpp>
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/execution.hpp>
@@ -37,13 +35,11 @@ class executor_work_guard;
 
 #endif // !defined(BOOST_ASIO_EXECUTOR_WORK_GUARD_DECL)
 
+#if defined(GENERATING_DOCUMENTATION)
+
 /// An object of type @c executor_work_guard controls ownership of executor work
 /// within a scope.
-#if defined(GENERATING_DOCUMENTATION)
 template <typename Executor>
-#else // defined(GENERATING_DOCUMENTATION)
-template <typename Executor, typename, typename>
-#endif // defined(GENERATING_DOCUMENTATION)
 class executor_work_guard
 {
 public:
@@ -54,6 +50,50 @@ public:
   /**
    * Stores a copy of @c e and calls <tt>on_work_started()</tt> on it.
    */
+  explicit executor_work_guard(const executor_type& e) BOOST_ASIO_NOEXCEPT;
+
+  /// Copy constructor.
+  executor_work_guard(const executor_work_guard& other) BOOST_ASIO_NOEXCEPT;
+
+  /// Move constructor.
+  executor_work_guard(executor_work_guard&& other) BOOST_ASIO_NOEXCEPT;
+
+  /// Destructor.
+  /**
+   * Unless the object has already been reset, or is in a moved-from state,
+   * calls <tt>on_work_finished()</tt> on the stored executor.
+   */
+  ~executor_work_guard();
+
+  /// Obtain the associated executor.
+  executor_type get_executor() const BOOST_ASIO_NOEXCEPT;
+
+  /// Whether the executor_work_guard object owns some outstanding work.
+  bool owns_work() const BOOST_ASIO_NOEXCEPT;
+
+  /// Indicate that the work is no longer outstanding.
+  /**
+   * Unless the object has already been reset, or is in a moved-from state,
+   * calls <tt>on_work_finished()</tt> on the stored executor.
+   */
+  void reset() BOOST_ASIO_NOEXCEPT;
+};
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+#if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
+
+template <typename Executor>
+class executor_work_guard<Executor,
+    typename enable_if<
+      is_executor<Executor>::value
+    >::type>
+{
+public:
+  typedef Executor executor_type;
+
   explicit executor_work_guard(const executor_type& e) BOOST_ASIO_NOEXCEPT
     : executor_(e),
       owns_(true)
@@ -61,7 +101,6 @@ public:
     executor_.on_work_started();
   }
 
-  /// Copy constructor.
   executor_work_guard(const executor_work_guard& other) BOOST_ASIO_NOEXCEPT
     : executor_(other.executor_),
       owns_(other.owns_)
@@ -70,44 +109,31 @@ public:
       executor_.on_work_started();
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move constructor.
+#if defined(BOOST_ASIO_HAS_MOVE)
   executor_work_guard(executor_work_guard&& other) BOOST_ASIO_NOEXCEPT
     : executor_(BOOST_ASIO_MOVE_CAST(Executor)(other.executor_)),
       owns_(other.owns_)
   {
     other.owns_ = false;
   }
-#endif //  defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+#endif // defined(BOOST_ASIO_HAS_MOVE)
 
-  /// Destructor.
-  /**
-   * Unless the object has already been reset, or is in a moved-from state,
-   * calls <tt>on_work_finished()</tt> on the stored executor.
-   */
   ~executor_work_guard()
   {
     if (owns_)
       executor_.on_work_finished();
   }
 
-  /// Obtain the associated executor.
   executor_type get_executor() const BOOST_ASIO_NOEXCEPT
   {
     return executor_;
   }
 
-  /// Whether the executor_work_guard object owns some outstanding work.
   bool owns_work() const BOOST_ASIO_NOEXCEPT
   {
     return owns_;
   }
 
-  /// Indicate that the work is no longer outstanding.
-  /**
-   * Unless the object has already been reset, or is in a moved-from state,
-   * calls <tt>on_work_finished()</tt> on the stored executor.
-   */
   void reset() BOOST_ASIO_NOEXCEPT
   {
     if (owns_)
@@ -125,7 +151,7 @@ private:
   bool owns_;
 };
 
-#if !defined(GENERATING_DOCUMENTATION)
+#endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 
 template <typename Executor>
 class executor_work_guard<Executor,
@@ -220,7 +246,8 @@ private:
 
 /// Create an @ref executor_work_guard object.
 template <typename Executor>
-inline executor_work_guard<Executor> make_work_guard(const Executor& ex,
+BOOST_ASIO_NODISCARD inline executor_work_guard<Executor>
+make_work_guard(const Executor& ex,
     typename constraint<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
     >::type = 0)
@@ -230,7 +257,8 @@ inline executor_work_guard<Executor> make_work_guard(const Executor& ex,
 
 /// Create an @ref executor_work_guard object.
 template <typename ExecutionContext>
-inline executor_work_guard<typename ExecutionContext::executor_type>
+BOOST_ASIO_NODISCARD inline
+executor_work_guard<typename ExecutionContext::executor_type>
 make_work_guard(ExecutionContext& ctx,
     typename constraint<
       is_convertible<ExecutionContext&, execution_context&>::value
@@ -242,7 +270,8 @@ make_work_guard(ExecutionContext& ctx,
 
 /// Create an @ref executor_work_guard object.
 template <typename T>
-inline executor_work_guard<typename associated_executor<T>::type>
+BOOST_ASIO_NODISCARD inline
+executor_work_guard<typename associated_executor<T>::type>
 make_work_guard(const T& t,
     typename constraint<
       !is_executor<T>::value
@@ -260,7 +289,8 @@ make_work_guard(const T& t,
 
 /// Create an @ref executor_work_guard object.
 template <typename T, typename Executor>
-inline executor_work_guard<typename associated_executor<T, Executor>::type>
+BOOST_ASIO_NODISCARD inline
+executor_work_guard<typename associated_executor<T, Executor>::type>
 make_work_guard(const T& t, const Executor& ex,
     typename constraint<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
@@ -272,7 +302,7 @@ make_work_guard(const T& t, const Executor& ex,
 
 /// Create an @ref executor_work_guard object.
 template <typename T, typename ExecutionContext>
-inline executor_work_guard<typename associated_executor<T,
+BOOST_ASIO_NODISCARD inline executor_work_guard<typename associated_executor<T,
   typename ExecutionContext::executor_type>::type>
 make_work_guard(const T& t, ExecutionContext& ctx,
     typename constraint<
@@ -299,6 +329,4 @@ make_work_guard(const T& t, ExecutionContext& ctx,
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS)
-
 #endif // BOOST_ASIO_EXECUTOR_WORK_GUARD_HPP
diff --git a/boost/asio/experimental/append.hpp b/boost/asio/experimental/append.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..512e894c2cdbce593d7a9dbe344c6baccce8b90f
--- /dev/null
+++ b/boost/asio/experimental/append.hpp
@@ -0,0 +1,73 @@
+//
+// experimental/append.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_APPEND_HPP
+#define BOOST_ASIO_EXPERIMENTAL_APPEND_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <tuple>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+/// Completion token type used to specify that the completion handler
+/// arguments should be passed additional values after the results of the
+/// operation.
+template <typename CompletionToken, typename... Values>
+class append_t
+{
+public:
+  /// Constructor.
+  template <typename T, typename... V>
+  BOOST_ASIO_CONSTEXPR explicit append_t(
+      BOOST_ASIO_MOVE_ARG(T) completion_token,
+      BOOST_ASIO_MOVE_ARG(V)... values)
+    : token_(BOOST_ASIO_MOVE_CAST(T)(completion_token)),
+      values_(BOOST_ASIO_MOVE_CAST(V)(values)...)
+  {
+  }
+
+//private:
+  CompletionToken token_;
+  std::tuple<Values...> values_;
+};
+
+/// Completion token type used to specify that the completion handler
+/// arguments should be passed additional values after the results of the
+/// operation.
+template <typename CompletionToken, typename... Values>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONSTEXPR append_t<
+  typename decay<CompletionToken>::type, typename decay<Values>::type...>
+append(BOOST_ASIO_MOVE_ARG(CompletionToken) completion_token,
+    BOOST_ASIO_MOVE_ARG(Values)... values)
+{
+  return append_t<
+    typename decay<CompletionToken>::type, typename decay<Values>::type...>(
+      BOOST_ASIO_MOVE_CAST(CompletionToken)(completion_token),
+      BOOST_ASIO_MOVE_CAST(Values)(values)...);
+}
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/experimental/impl/append.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_APPEND_HPP
diff --git a/boost/asio/experimental/as_single.hpp b/boost/asio/experimental/as_single.hpp
index 1bb1cb888c848d69afafc6051421477a97abfa33..c047276987977fcda81a03459b5a1294a458bd9d 100644
--- a/boost/asio/experimental/as_single.hpp
+++ b/boost/asio/experimental/as_single.hpp
@@ -2,7 +2,7 @@
 // experimental/as_single.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -119,7 +119,8 @@ public:
 /// Create a completion token to specify that the completion handler arguments
 /// should be combined into a single argument.
 template <typename CompletionToken>
-inline BOOST_ASIO_CONSTEXPR as_single_t<typename decay<CompletionToken>::type>
+BOOST_ASIO_NODISCARD inline
+BOOST_ASIO_CONSTEXPR as_single_t<typename decay<CompletionToken>::type>
 as_single(BOOST_ASIO_MOVE_ARG(CompletionToken) completion_token)
 {
   return as_single_t<typename decay<CompletionToken>::type>(
diff --git a/boost/asio/experimental/as_tuple.hpp b/boost/asio/experimental/as_tuple.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..12552d7720b58721b19cbd76258f5b7400339fda
--- /dev/null
+++ b/boost/asio/experimental/as_tuple.hpp
@@ -0,0 +1,134 @@
+//
+// experimental/as_tuple.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_AS_TUPLE_HPP
+#define BOOST_ASIO_EXPERIMENTAL_AS_TUPLE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+/// Completion token type used to specify that the completion handler
+/// arguments should be combined into a single tuple argument.
+/**
+ * The as_tuple_t class is used to indicate that any arguments to the
+ * completion handler should be combined and passed as a single tuple argument.
+ * The arguments are first moved into a @c std::tuple and that tuple is then
+ * passed to the completion handler.
+ */
+template <typename CompletionToken>
+class as_tuple_t
+{
+public:
+  /// Tag type used to prevent the "default" constructor from being used for
+  /// conversions.
+  struct default_constructor_tag {};
+
+  /// Default constructor.
+  /**
+   * This constructor is only valid if the underlying completion token is
+   * default constructible and move constructible. The underlying completion
+   * token is itself defaulted as an argument to allow it to capture a source
+   * location.
+   */
+  BOOST_ASIO_CONSTEXPR as_tuple_t(
+      default_constructor_tag = default_constructor_tag(),
+      CompletionToken token = CompletionToken())
+    : token_(BOOST_ASIO_MOVE_CAST(CompletionToken)(token))
+  {
+  }
+
+  /// Constructor.
+  template <typename T>
+  BOOST_ASIO_CONSTEXPR explicit as_tuple_t(
+      BOOST_ASIO_MOVE_ARG(T) completion_token)
+    : token_(BOOST_ASIO_MOVE_CAST(T)(completion_token))
+  {
+  }
+
+  /// Adapts an executor to add the @c as_tuple_t completion token as the
+  /// default.
+  template <typename InnerExecutor>
+  struct executor_with_default : InnerExecutor
+  {
+    /// Specify @c as_tuple_t as the default completion token type.
+    typedef as_tuple_t default_completion_token_type;
+
+    /// Construct the adapted executor from the inner executor type.
+    template <typename InnerExecutor1>
+    executor_with_default(const InnerExecutor1& ex,
+        typename constraint<
+          conditional<
+            !is_same<InnerExecutor1, executor_with_default>::value,
+            is_convertible<InnerExecutor1, InnerExecutor>,
+            false_type
+          >::type::value
+        >::type = 0) BOOST_ASIO_NOEXCEPT
+      : InnerExecutor(ex)
+    {
+    }
+  };
+
+  /// Type alias to adapt an I/O object to use @c as_tuple_t as its
+  /// default completion token type.
+#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES) \
+  || defined(GENERATING_DOCUMENTATION)
+  template <typename T>
+  using as_default_on_t = typename T::template rebind_executor<
+      executor_with_default<typename T::executor_type> >::other;
+#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+  /// Function helper to adapt an I/O object to use @c as_tuple_t as its
+  /// default completion token type.
+  template <typename T>
+  static typename decay<T>::type::template rebind_executor<
+      executor_with_default<typename decay<T>::type::executor_type>
+    >::other
+  as_default_on(BOOST_ASIO_MOVE_ARG(T) object)
+  {
+    return typename decay<T>::type::template rebind_executor<
+        executor_with_default<typename decay<T>::type::executor_type>
+      >::other(BOOST_ASIO_MOVE_CAST(T)(object));
+  }
+
+//private:
+  CompletionToken token_;
+};
+
+/// Create a completion token to specify that the completion handler arguments
+/// should be combined into a single tuple argument.
+template <typename CompletionToken>
+BOOST_ASIO_NODISCARD inline
+BOOST_ASIO_CONSTEXPR as_tuple_t<typename decay<CompletionToken>::type>
+as_tuple(BOOST_ASIO_MOVE_ARG(CompletionToken) completion_token)
+{
+  return as_tuple_t<typename decay<CompletionToken>::type>(
+      BOOST_ASIO_MOVE_CAST(CompletionToken)(completion_token));
+}
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/experimental/impl/as_tuple.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_AS_TUPLE_HPP
diff --git a/boost/asio/experimental/awaitable_operators.hpp b/boost/asio/experimental/awaitable_operators.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..1a02c20430655899c72f5ae76d0497fe80c2befc
--- /dev/null
+++ b/boost/asio/experimental/awaitable_operators.hpp
@@ -0,0 +1,539 @@
+//
+// experimental/awaitable_operators.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_AWAITABLE_OPERATORS_HPP
+#define BOOST_ASIO_EXPERIMENTAL_AWAITABLE_OPERATORS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <optional>
+#include <stdexcept>
+#include <tuple>
+#include <variant>
+#include <boost/asio/awaitable.hpp>
+#include <boost/asio/co_spawn.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/experimental/deferred.hpp>
+#include <boost/asio/experimental/parallel_group.hpp>
+#include <boost/asio/multiple_exceptions.hpp>
+#include <boost/asio/this_coro.hpp>
+#include <boost/asio/use_awaitable.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace awaitable_operators {
+namespace detail {
+
+template <typename T, typename Executor>
+awaitable<T, Executor> awaitable_wrap(awaitable<T, Executor> a,
+    typename constraint<is_constructible<T>::value>::type* = 0)
+{
+  return a;
+}
+
+template <typename T, typename Executor>
+awaitable<std::optional<T>, Executor> awaitable_wrap(awaitable<T, Executor> a,
+    typename constraint<!is_constructible<T>::value>::type* = 0)
+{
+  co_return std::optional<T>(co_await std::move(a));
+}
+
+template <typename T>
+T& awaitable_unwrap(typename conditional<true, T, void>::type& r,
+    typename constraint<is_constructible<T>::value>::type* = 0)
+{
+  return r;
+}
+
+template <typename T>
+T& awaitable_unwrap(std::optional<typename conditional<true, T, void>::type>& r,
+    typename constraint<!is_constructible<T>::value>::type* = 0)
+{
+  return *r;
+}
+
+} // namespace detail
+
+/// Wait for both operations to succeed.
+/**
+ * If one operations fails, the other is cancelled as the AND-condition can no
+ * longer be satisfied.
+ */
+template <typename Executor>
+awaitable<void, Executor> operator&&(
+    awaitable<void, Executor> t, awaitable<void, Executor> u)
+{
+  auto ex = co_await this_coro::executor;
+
+  auto [order, ex0, ex1] =
+    co_await make_parallel_group(
+      co_spawn(ex, std::move(t), deferred),
+      co_spawn(ex, std::move(u), deferred)
+    ).async_wait(
+      wait_for_one_error(),
+      use_awaitable_t<Executor>{}
+    );
+
+  if (ex0 && ex1)
+    throw multiple_exceptions(ex0);
+  if (ex0)
+    std::rethrow_exception(ex0);
+  if (ex1)
+    std::rethrow_exception(ex1);
+  co_return;
+}
+
+/// Wait for both operations to succeed.
+/**
+ * If one operations fails, the other is cancelled as the AND-condition can no
+ * longer be satisfied.
+ */
+template <typename U, typename Executor>
+awaitable<U, Executor> operator&&(
+    awaitable<void, Executor> t, awaitable<U, Executor> u)
+{
+  auto ex = co_await this_coro::executor;
+
+  auto [order, ex0, ex1, r1] =
+    co_await make_parallel_group(
+      co_spawn(ex, std::move(t), deferred),
+      co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)
+    ).async_wait(
+      wait_for_one_error(),
+      use_awaitable_t<Executor>{}
+    );
+
+  if (ex0 && ex1)
+    throw multiple_exceptions(ex0);
+  if (ex0)
+    std::rethrow_exception(ex0);
+  if (ex1)
+    std::rethrow_exception(ex1);
+  co_return std::move(detail::awaitable_unwrap<U>(r1));
+}
+
+/// Wait for both operations to succeed.
+/**
+ * If one operations fails, the other is cancelled as the AND-condition can no
+ * longer be satisfied.
+ */
+template <typename T, typename Executor>
+awaitable<T, Executor> operator&&(
+    awaitable<T, Executor> t, awaitable<void, Executor> u)
+{
+  auto ex = co_await this_coro::executor;
+
+  auto [order, ex0, r0, ex1] =
+    co_await make_parallel_group(
+      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
+      co_spawn(ex, std::move(u), deferred)
+    ).async_wait(
+      wait_for_one_error(),
+      use_awaitable_t<Executor>{}
+    );
+
+  if (ex0 && ex1)
+    throw multiple_exceptions(ex0);
+  if (ex0)
+    std::rethrow_exception(ex0);
+  if (ex1)
+    std::rethrow_exception(ex1);
+  co_return std::move(detail::awaitable_unwrap<T>(r0));
+}
+
+/// Wait for both operations to succeed.
+/**
+ * If one operations fails, the other is cancelled as the AND-condition can no
+ * longer be satisfied.
+ */
+template <typename T, typename U, typename Executor>
+awaitable<std::tuple<T, U>, Executor> operator&&(
+    awaitable<T, Executor> t, awaitable<U, Executor> u)
+{
+  auto ex = co_await this_coro::executor;
+
+  auto [order, ex0, r0, ex1, r1] =
+    co_await make_parallel_group(
+      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
+      co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)
+    ).async_wait(
+      wait_for_one_error(),
+      use_awaitable_t<Executor>{}
+    );
+
+  if (ex0 && ex1)
+    throw multiple_exceptions(ex0);
+  if (ex0)
+    std::rethrow_exception(ex0);
+  if (ex1)
+    std::rethrow_exception(ex1);
+  co_return std::make_tuple(
+      std::move(detail::awaitable_unwrap<T>(r0)),
+      std::move(detail::awaitable_unwrap<U>(r1)));
+}
+
+/// Wait for both operations to succeed.
+/**
+ * If one operations fails, the other is cancelled as the AND-condition can no
+ * longer be satisfied.
+ */
+template <typename... T, typename Executor>
+awaitable<std::tuple<T..., std::monostate>, Executor> operator&&(
+    awaitable<std::tuple<T...>, Executor> t, awaitable<void, Executor> u)
+{
+  auto ex = co_await this_coro::executor;
+
+  auto [order, ex0, r0, ex1, r1] =
+    co_await make_parallel_group(
+      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
+      co_spawn(ex, std::move(u), deferred)
+    ).async_wait(
+      wait_for_one_error(),
+      use_awaitable_t<Executor>{}
+    );
+
+  if (ex0 && ex1)
+    throw multiple_exceptions(ex0);
+  if (ex0)
+    std::rethrow_exception(ex0);
+  if (ex1)
+    std::rethrow_exception(ex1);
+  co_return std::move(detail::awaitable_unwrap<std::tuple<T...>>(r0));
+}
+
+/// Wait for both operations to succeed.
+/**
+ * If one operations fails, the other is cancelled as the AND-condition can no
+ * longer be satisfied.
+ */
+template <typename... T, typename U, typename Executor>
+awaitable<std::tuple<T..., U>, Executor> operator&&(
+    awaitable<std::tuple<T...>, Executor> t, awaitable<U, Executor> u)
+{
+  auto ex = co_await this_coro::executor;
+
+  auto [order, ex0, r0, ex1, r1] =
+    co_await make_parallel_group(
+      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
+      co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)
+    ).async_wait(
+      wait_for_one_error(),
+      use_awaitable_t<Executor>{}
+    );
+
+  if (ex0 && ex1)
+    throw multiple_exceptions(ex0);
+  if (ex0)
+    std::rethrow_exception(ex0);
+  if (ex1)
+    std::rethrow_exception(ex1);
+  co_return std::tuple_cat(
+      std::move(detail::awaitable_unwrap<std::tuple<T...>>(r0)),
+      std::make_tuple(std::move(detail::awaitable_unwrap<U>(r1))));
+}
+
+/// Wait for one operation to succeed.
+/**
+ * If one operations succeeds, the other is cancelled as the OR-condition is
+ * already satisfied.
+ */
+template <typename Executor>
+awaitable<std::variant<std::monostate, std::monostate>, Executor> operator||(
+    awaitable<void, Executor> t, awaitable<void, Executor> u)
+{
+  auto ex = co_await this_coro::executor;
+
+  auto [order, ex0, ex1] =
+    co_await make_parallel_group(
+      co_spawn(ex, std::move(t), deferred),
+      co_spawn(ex, std::move(u), deferred)
+    ).async_wait(
+      wait_for_one_success(),
+      use_awaitable_t<Executor>{}
+    );
+
+  if (order[0] == 0)
+  {
+    if (!ex0)
+      co_return std::variant<std::monostate, std::monostate>{
+          std::in_place_index<0>};
+    if (!ex1)
+      co_return std::variant<std::monostate, std::monostate>{
+          std::in_place_index<1>};
+    throw multiple_exceptions(ex0);
+  }
+  else
+  {
+    if (!ex1)
+      co_return std::variant<std::monostate, std::monostate>{
+          std::in_place_index<1>};
+    if (!ex0)
+      co_return std::variant<std::monostate, std::monostate>{
+          std::in_place_index<0>};
+    throw multiple_exceptions(ex1);
+  }
+}
+
+/// Wait for one operation to succeed.
+/**
+ * If one operations succeeds, the other is cancelled as the OR-condition is
+ * already satisfied.
+ */
+template <typename U, typename Executor>
+awaitable<std::variant<std::monostate, U>, Executor> operator||(
+    awaitable<void, Executor> t, awaitable<U, Executor> u)
+{
+  auto ex = co_await this_coro::executor;
+
+  auto [order, ex0, ex1, r1] =
+    co_await make_parallel_group(
+      co_spawn(ex, std::move(t), deferred),
+      co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)
+    ).async_wait(
+      wait_for_one_success(),
+      use_awaitable_t<Executor>{}
+    );
+
+  if (order[0] == 0)
+  {
+    if (!ex0)
+      co_return std::variant<std::monostate, U>{
+          std::in_place_index<0>};
+    if (!ex1)
+      co_return std::variant<std::monostate, U>{
+          std::in_place_index<1>,
+          std::move(detail::awaitable_unwrap<U>(r1))};
+    throw multiple_exceptions(ex0);
+  }
+  else
+  {
+    if (!ex1)
+      co_return std::variant<std::monostate, U>{
+          std::in_place_index<1>,
+          std::move(detail::awaitable_unwrap<U>(r1))};
+    if (!ex0)
+      co_return std::variant<std::monostate, U>{
+          std::in_place_index<0>};
+    throw multiple_exceptions(ex1);
+  }
+}
+
+/// Wait for one operation to succeed.
+/**
+ * If one operations succeeds, the other is cancelled as the OR-condition is
+ * already satisfied.
+ */
+template <typename T, typename Executor>
+awaitable<std::variant<T, std::monostate>, Executor> operator||(
+    awaitable<T, Executor> t, awaitable<void, Executor> u)
+{
+  auto ex = co_await this_coro::executor;
+
+  auto [order, ex0, r0, ex1] =
+    co_await make_parallel_group(
+      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
+      co_spawn(ex, std::move(u), deferred)
+    ).async_wait(
+      wait_for_one_success(),
+      use_awaitable_t<Executor>{}
+    );
+
+  if (order[0] == 0)
+  {
+    if (!ex0)
+      co_return std::variant<T, std::monostate>{
+          std::in_place_index<0>,
+          std::move(detail::awaitable_unwrap<T>(r0))};
+    if (!ex1)
+      co_return std::variant<T, std::monostate>{
+          std::in_place_index<1>};
+    throw multiple_exceptions(ex0);
+  }
+  else
+  {
+    if (!ex1)
+      co_return std::variant<T, std::monostate>{
+          std::in_place_index<1>};
+    if (!ex0)
+      co_return std::variant<T, std::monostate>{
+          std::in_place_index<0>,
+          std::move(detail::awaitable_unwrap<T>(r0))};
+    throw multiple_exceptions(ex1);
+  }
+}
+
+/// Wait for one operation to succeed.
+/**
+ * If one operations succeeds, the other is cancelled as the OR-condition is
+ * already satisfied.
+ */
+template <typename T, typename U, typename Executor>
+awaitable<std::variant<T, U>, Executor> operator||(
+    awaitable<T, Executor> t, awaitable<U, Executor> u)
+{
+  auto ex = co_await this_coro::executor;
+
+  auto [order, ex0, r0, ex1, r1] =
+    co_await make_parallel_group(
+      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
+      co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)
+    ).async_wait(
+      wait_for_one_success(),
+      use_awaitable_t<Executor>{}
+    );
+
+  if (order[0] == 0)
+  {
+    if (!ex0)
+      co_return std::variant<T, U>{
+          std::in_place_index<0>,
+          std::move(detail::awaitable_unwrap<T>(r0))};
+    if (!ex1)
+      co_return std::variant<T, U>{
+          std::in_place_index<1>,
+          std::move(detail::awaitable_unwrap<U>(r1))};
+    throw multiple_exceptions(ex0);
+  }
+  else
+  {
+    if (!ex1)
+      co_return std::variant<T, U>{
+          std::in_place_index<1>,
+          std::move(detail::awaitable_unwrap<U>(r1))};
+    if (!ex0)
+      co_return std::variant<T, U>{
+          std::in_place_index<0>,
+          std::move(detail::awaitable_unwrap<T>(r0))};
+    throw multiple_exceptions(ex1);
+  }
+}
+
+namespace detail {
+
+template <typename... T>
+struct widen_variant
+{
+  template <std::size_t I, typename SourceVariant>
+  static std::variant<T...> call(SourceVariant& source)
+  {
+    if (source.index() == I)
+      return std::variant<T...>{
+          std::in_place_index<I>, std::move(std::get<I>(source))};
+    else if constexpr (I + 1 < std::variant_size_v<SourceVariant>)
+      return call<I + 1>(source);
+    else
+      throw std::logic_error("empty variant");
+  }
+};
+
+} // namespace detail
+
+/// Wait for one operation to succeed.
+/**
+ * If one operations succeeds, the other is cancelled as the OR-condition is
+ * already satisfied.
+ */
+template <typename... T, typename Executor>
+awaitable<std::variant<T..., std::monostate>, Executor> operator||(
+    awaitable<std::variant<T...>, Executor> t, awaitable<void, Executor> u)
+{
+  auto ex = co_await this_coro::executor;
+
+  auto [order, ex0, r0, ex1] =
+    co_await make_parallel_group(
+      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
+      co_spawn(ex, std::move(u), deferred)
+    ).async_wait(
+      wait_for_one_success(),
+      use_awaitable_t<Executor>{}
+    );
+
+  using widen = detail::widen_variant<T..., std::monostate>;
+  if (order[0] == 0)
+  {
+    if (!ex0)
+      co_return widen::template call<0>(
+          detail::awaitable_unwrap<std::variant<T...>>(r0));
+    if (!ex1)
+      co_return std::variant<T..., std::monostate>{
+          std::in_place_index<sizeof...(T)>};
+    throw multiple_exceptions(ex0);
+  }
+  else
+  {
+    if (!ex1)
+      co_return std::variant<T..., std::monostate>{
+          std::in_place_index<sizeof...(T)>};
+    if (!ex0)
+      co_return widen::template call<0>(
+          detail::awaitable_unwrap<std::variant<T...>>(r0));
+    throw multiple_exceptions(ex1);
+  }
+}
+
+/// Wait for one operation to succeed.
+/**
+ * If one operations succeeds, the other is cancelled as the OR-condition is
+ * already satisfied.
+ */
+template <typename... T, typename U, typename Executor>
+awaitable<std::variant<T..., U>, Executor> operator||(
+    awaitable<std::variant<T...>, Executor> t, awaitable<U, Executor> u)
+{
+  auto ex = co_await this_coro::executor;
+
+  auto [order, ex0, r0, ex1, r1] =
+    co_await make_parallel_group(
+      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
+      co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)
+    ).async_wait(
+      wait_for_one_success(),
+      use_awaitable_t<Executor>{}
+    );
+
+  using widen = detail::widen_variant<T..., U>;
+  if (order[0] == 0)
+  {
+    if (!ex0)
+      co_return widen::template call<0>(
+          detail::awaitable_unwrap<std::variant<T...>>(r0));
+    if (!ex1)
+      co_return std::variant<T..., U>{
+          std::in_place_index<sizeof...(T)>,
+          std::move(detail::awaitable_unwrap<U>(r1))};
+    throw multiple_exceptions(ex0);
+  }
+  else
+  {
+    if (!ex1)
+      co_return std::variant<T..., U>{
+          std::in_place_index<sizeof...(T)>,
+          std::move(detail::awaitable_unwrap<U>(r1))};
+    if (!ex0)
+      co_return widen::template call<0>(
+          detail::awaitable_unwrap<std::variant<T...>>(r0));
+    throw multiple_exceptions(ex1);
+  }
+}
+
+} // namespace awaitable_operators
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_AWAITABLE_OPERATORS_HPP
diff --git a/boost/asio/experimental/basic_channel.hpp b/boost/asio/experimental/basic_channel.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ee90c885d8a5a4e6b8f507920673b49de84d7b07
--- /dev/null
+++ b/boost/asio/experimental/basic_channel.hpp
@@ -0,0 +1,432 @@
+//
+// experimental/basic_channel.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_BASIC_CHANNEL_HPP
+#define BOOST_ASIO_EXPERIMENTAL_BASIC_CHANNEL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/non_const_lvalue.hpp>
+#include <boost/asio/detail/null_mutex.hpp>
+#include <boost/asio/execution/executor.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/experimental/detail/channel_send_functions.hpp>
+#include <boost/asio/experimental/detail/channel_service.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+} // namespace detail
+
+/// A channel for messages.
+template <typename Executor, typename Traits, typename... Signatures>
+class basic_channel
+#if !defined(GENERATING_DOCUMENTATION)
+  : public detail::channel_send_functions<
+      basic_channel<Executor, Traits, Signatures...>,
+      Executor, Signatures...>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+private:
+  class initiate_async_send;
+  class initiate_async_receive;
+  typedef detail::channel_service<boost::asio::detail::null_mutex> service_type;
+  typedef typename service_type::template implementation_type<
+      Traits, Signatures...>::payload_type payload_type;
+
+  template <typename... PayloadSignatures,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(PayloadSignatures...) CompletionToken>
+  auto do_async_receive(detail::channel_payload<PayloadSignatures...>*,
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token)
+    -> decltype(
+        async_initiate<CompletionToken, PayloadSignatures...>(
+          declval<initiate_async_receive>(), token))
+  {
+    return async_initiate<CompletionToken, PayloadSignatures...>(
+        initiate_async_receive(this), token);
+  }
+
+public:
+  /// The type of the executor associated with the channel.
+  typedef Executor executor_type;
+
+  /// Rebinds the channel type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The channel type when rebound to the specified executor.
+    typedef basic_channel<Executor1, Traits, Signatures...> other;
+  };
+
+  /// The traits type associated with the channel.
+  typedef typename Traits::template rebind<Signatures...>::other traits_type;
+
+  /// Construct a basic_channel.
+  /**
+   * This constructor creates and channel.
+   *
+   * @param ex The I/O executor that the channel will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the channel.
+   *
+   * @param max_buffer_size The maximum number of messages that may be buffered
+   * in the channel.
+   */
+  basic_channel(const executor_type& ex, std::size_t max_buffer_size = 0)
+    : service_(&boost::asio::use_service<service_type>(
+            basic_channel::get_context(ex))),
+      impl_(),
+      executor_(ex)
+  {
+    service_->construct(impl_, max_buffer_size);
+  }
+
+  /// Construct and open a basic_channel.
+  /**
+   * This constructor creates and opens a channel.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the channel will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the channel.
+   *
+   * @param max_buffer_size The maximum number of messages that may be buffered
+   * in the channel.
+   */
+  template <typename ExecutionContext>
+  basic_channel(ExecutionContext& context, std::size_t max_buffer_size = 0,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : service_(&boost::asio::use_service<service_type>(context)),
+      impl_(),
+      executor_(context.get_executor())
+  {
+    service_->construct(impl_, max_buffer_size);
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_channel from another.
+  /**
+   * This constructor moves a channel from one object to another.
+   *
+   * @param other The other basic_channel object from which the move will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_channel(const executor_type&) constructor.
+   */
+  basic_channel(basic_channel&& other)
+    : service_(other.service_),
+      executor_(other.executor_)
+  {
+    service_->move_construct(impl_, other.impl_);
+  }
+
+  /// Move-assign a basic_channel from another.
+  /**
+   * This assignment operator moves a channel from one object to another.
+   * Cancels any outstanding asynchronous operations associated with the target
+   * object.
+   *
+   * @param other The other basic_channel object from which the move will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_channel(const executor_type&)
+   * constructor.
+   */
+  basic_channel& operator=(basic_channel&& other)
+  {
+    if (this != &other)
+    {
+      service_->move_assign(impl_, *other.service_, other.impl_);
+      executor_.~executor_type();
+      new (&executor_) executor_type(other.executor_);
+      service_ = other.service_;
+    }
+    return *this;
+  }
+
+  // All channels have access to each other's implementations.
+  template <typename, typename, typename...>
+  friend class basic_channel;
+
+  /// Move-construct a basic_channel from another.
+  /**
+   * This constructor moves a channel from one object to another.
+   *
+   * @param other The other basic_channel object from which the move will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_channel(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  basic_channel(
+      basic_channel<Executor1, Traits, Signatures...>&& other,
+      typename constraint<
+          is_convertible<Executor1, Executor>::value
+      >::type = 0)
+    : service_(other.service_),
+      executor_(other.executor_)
+  {
+    service_->move_construct(impl_, *other.service_, other.impl_);
+  }
+
+  /// Move-assign a basic_channel from another.
+  /**
+   * This assignment operator moves a channel from one object to another.
+   * Cancels any outstanding asynchronous operations associated with the target
+   * object.
+   *
+   * @param other The other basic_channel object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_channel(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  typename constraint<
+    is_convertible<Executor1, Executor>::value,
+    basic_channel&
+  >::type operator=(basic_channel<Executor1, Traits, Signatures...>&& other)
+  {
+    if (this != &other)
+    {
+      service_->move_assign(impl_, *other.service_, other.impl_);
+      executor_.~executor_type();
+      new (&executor_) executor_type(other.executor_);
+      service_ = other.service_;
+    }
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destructor.
+  ~basic_channel()
+  {
+    service_->destroy(impl_);
+  }
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() BOOST_ASIO_NOEXCEPT
+  {
+    return executor_;
+  }
+
+  /// Get the capacity of the channel's buffer.
+  std::size_t capacity() BOOST_ASIO_NOEXCEPT
+  {
+    return service_->capacity(impl_);
+  }
+
+  /// Determine whether the channel is open.
+  bool is_open() const BOOST_ASIO_NOEXCEPT
+  {
+    return service_->is_open(impl_);
+  }
+
+  /// Reset the channel to its initial state.
+  void reset()
+  {
+    service_->reset(impl_);
+  }
+
+  /// Close the channel.
+  void close()
+  {
+    service_->close(impl_);
+  }
+
+  /// Cancel all asynchronous operations waiting on the channel.
+  /**
+   * All outstanding send operations will complete with the error
+   * @c boost::asio::experimental::error::channel_canceld. Outstanding receive
+   * operations complete with the result as determined by the channel traits.
+   */
+  void cancel()
+  {
+    service_->cancel(impl_);
+  }
+
+  /// Determine whether a message can be received without blocking.
+  bool ready() const BOOST_ASIO_NOEXCEPT
+  {
+    return service_->ready(impl_);
+  }
+
+#if defined(GENERATING_DOCUMENTATION)
+
+  /// Try to send a message without blocking.
+  /**
+   * Fails if the buffer is full and there are no waiting receive operations.
+   *
+   * @returns @c true on success, @c false on failure.
+   */
+  template <typename... Args>
+  bool try_send(BOOST_ASIO_MOVE_ARG(Args)... args);
+
+  /// Try to send a number of messages without blocking.
+  /**
+   * @returns The number of messages that were sent.
+   */
+  template <typename... Args>
+  std::size_t try_send_n(std::size_t count, BOOST_ASIO_MOVE_ARG(Args)... args);
+
+  /// Asynchronously send a message.
+  /**
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   */
+  template <typename... Args,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
+        CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  auto async_send(BOOST_ASIO_MOVE_ARG(Args)... args,
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token);
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Try to receive a message without blocking.
+  /**
+   * Fails if the buffer is full and there are no waiting receive operations.
+   *
+   * @returns @c true on success, @c false on failure.
+   */
+  template <typename Handler>
+  bool try_receive(BOOST_ASIO_MOVE_ARG(Handler) handler)
+  {
+    return service_->try_receive(impl_, BOOST_ASIO_MOVE_CAST(Handler)(handler));
+  }
+
+  /// Asynchronously receive a message.
+  /**
+   * @par Completion Signature
+   * As determined by the <tt>Signatures...</tt> template parameter and the
+   * channel traits.
+   */
+  template <typename CompletionToken
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  auto async_receive(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
+#if !defined(GENERATING_DOCUMENTATION)
+    -> decltype(
+        this->do_async_receive(static_cast<payload_type*>(0),
+          BOOST_ASIO_MOVE_CAST(CompletionToken)(token)))
+#endif // !defined(GENERATING_DOCUMENTATION)
+  {
+    return this->do_async_receive(static_cast<payload_type*>(0),
+        BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
+  }
+
+private:
+  // Disallow copying and assignment.
+  basic_channel(const basic_channel&) BOOST_ASIO_DELETED;
+  basic_channel& operator=(const basic_channel&) BOOST_ASIO_DELETED;
+
+  template <typename, typename, typename...>
+  friend class detail::channel_send_functions;
+
+  // Helper function to get an executor's context.
+  template <typename T>
+  static execution_context& get_context(const T& t,
+      typename enable_if<execution::is_executor<T>::value>::type* = 0)
+  {
+    return boost::asio::query(t, execution::context);
+  }
+
+  // Helper function to get an executor's context.
+  template <typename T>
+  static execution_context& get_context(const T& t,
+      typename enable_if<!execution::is_executor<T>::value>::type* = 0)
+  {
+    return t.context();
+  }
+
+  class initiate_async_send
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_send(basic_channel* self)
+      : self_(self)
+    {
+    }
+
+    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename SendHandler>
+    void operator()(BOOST_ASIO_MOVE_ARG(SendHandler) handler,
+        BOOST_ASIO_MOVE_ARG(payload_type) payload) const
+    {
+      boost::asio::detail::non_const_lvalue<SendHandler> handler2(handler);
+      self_->service_->async_send(self_->impl_,
+          BOOST_ASIO_MOVE_CAST(payload_type)(payload),
+          handler2.value, self_->get_executor());
+    }
+
+  private:
+    basic_channel* self_;
+  };
+
+  class initiate_async_receive
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_receive(basic_channel* self)
+      : self_(self)
+    {
+    }
+
+    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename ReceiveHandler>
+    void operator()(BOOST_ASIO_MOVE_ARG(ReceiveHandler) handler) const
+    {
+      boost::asio::detail::non_const_lvalue<ReceiveHandler> handler2(handler);
+      self_->service_->async_receive(self_->impl_,
+          handler2.value, self_->get_executor());
+    }
+
+  private:
+    basic_channel* self_;
+  };
+
+  // The service associated with the I/O object.
+  service_type* service_;
+
+  // The underlying implementation of the I/O object.
+  typename service_type::template implementation_type<
+      Traits, Signatures...> impl_;
+
+  // The associated executor.
+  Executor executor_;
+};
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_BASIC_CHANNEL_HPP
diff --git a/boost/asio/experimental/basic_concurrent_channel.hpp b/boost/asio/experimental/basic_concurrent_channel.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b8b3969239e2370cd782ea850d080f57182fc909
--- /dev/null
+++ b/boost/asio/experimental/basic_concurrent_channel.hpp
@@ -0,0 +1,432 @@
+//
+// experimental/basic_concurrent_channel.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_BASIC_CONCURRENT_CHANNEL_HPP
+#define BOOST_ASIO_EXPERIMENTAL_BASIC_CONCURRENT_CHANNEL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/non_const_lvalue.hpp>
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/execution/executor.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/experimental/detail/channel_send_functions.hpp>
+#include <boost/asio/experimental/detail/channel_service.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+} // namespace detail
+
+/// A channel for messages.
+template <typename Executor, typename Traits, typename... Signatures>
+class basic_concurrent_channel
+#if !defined(GENERATING_DOCUMENTATION)
+  : public detail::channel_send_functions<
+      basic_concurrent_channel<Executor, Traits, Signatures...>,
+      Executor, Signatures...>
+#endif // !defined(GENERATING_DOCUMENTATION)
+{
+private:
+  class initiate_async_send;
+  class initiate_async_receive;
+  typedef detail::channel_service<boost::asio::detail::mutex> service_type;
+  typedef typename service_type::template implementation_type<
+      Traits, Signatures...>::payload_type payload_type;
+
+  template <typename... PayloadSignatures,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(PayloadSignatures...) CompletionToken>
+  auto do_async_receive(detail::channel_payload<PayloadSignatures...>*,
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token)
+    -> decltype(
+        async_initiate<CompletionToken, PayloadSignatures...>(
+          declval<initiate_async_receive>(), token))
+  {
+    return async_initiate<CompletionToken, PayloadSignatures...>(
+        initiate_async_receive(this), token);
+  }
+
+public:
+  /// The type of the executor associated with the channel.
+  typedef Executor executor_type;
+
+  /// Rebinds the channel type to another executor.
+  template <typename Executor1>
+  struct rebind_executor
+  {
+    /// The channel type when rebound to the specified executor.
+    typedef basic_concurrent_channel<Executor1, Traits, Signatures...> other;
+  };
+
+  /// The traits type associated with the channel.
+  typedef typename Traits::template rebind<Signatures...>::other traits_type;
+
+  /// Construct a basic_concurrent_channel.
+  /**
+   * This constructor creates and channel.
+   *
+   * @param ex The I/O executor that the channel will use, by default, to
+   * dispatch handlers for any asynchronous operations performed on the channel.
+   *
+   * @param max_buffer_size The maximum number of messages that may be buffered
+   * in the channel.
+   */
+  basic_concurrent_channel(const executor_type& ex,
+      std::size_t max_buffer_size = 0)
+    : service_(&boost::asio::use_service<service_type>(
+            basic_concurrent_channel::get_context(ex))),
+      impl_(),
+      executor_(ex)
+  {
+    service_->construct(impl_, max_buffer_size);
+  }
+
+  /// Construct and open a basic_concurrent_channel.
+  /**
+   * This constructor creates and opens a channel.
+   *
+   * @param context An execution context which provides the I/O executor that
+   * the channel will use, by default, to dispatch handlers for any asynchronous
+   * operations performed on the channel.
+   *
+   * @param max_buffer_size The maximum number of messages that may be buffered
+   * in the channel.
+   */
+  template <typename ExecutionContext>
+  basic_concurrent_channel(ExecutionContext& context,
+      std::size_t max_buffer_size = 0,
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : service_(&boost::asio::use_service<service_type>(context)),
+      impl_(),
+      executor_(context.get_executor())
+  {
+    service_->construct(impl_, max_buffer_size);
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+  /// Move-construct a basic_concurrent_channel from another.
+  /**
+   * This constructor moves a channel from one object to another.
+   *
+   * @param other The other basic_concurrent_channel object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_concurrent_channel(const executor_type&)
+   * constructor.
+   */
+  basic_concurrent_channel(basic_concurrent_channel&& other)
+    : service_(other.service_),
+      executor_(other.executor_)
+  {
+    service_->move_construct(impl_, other.impl_);
+  }
+
+  /// Move-assign a basic_concurrent_channel from another.
+  /**
+   * This assignment operator moves a channel from one object to another.
+   * Cancels any outstanding asynchronous operations associated with the target
+   * object.
+   *
+   * @param other The other basic_concurrent_channel object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_concurrent_channel(const executor_type&)
+   * constructor.
+   */
+  basic_concurrent_channel& operator=(basic_concurrent_channel&& other)
+  {
+    if (this != &other)
+    {
+      service_->move_assign(impl_, *other.service_, other.impl_);
+      executor_.~executor_type();
+      new (&executor_) executor_type(other.executor_);
+      service_ = other.service_;
+    }
+    return *this;
+  }
+
+  // All channels have access to each other's implementations.
+  template <typename, typename, typename...>
+  friend class basic_concurrent_channel;
+
+  /// Move-construct a basic_concurrent_channel from another.
+  /**
+   * This constructor moves a channel from one object to another.
+   *
+   * @param other The other basic_concurrent_channel object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_concurrent_channel(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  basic_concurrent_channel(
+      basic_concurrent_channel<Executor1, Traits, Signatures...>&& other,
+      typename constraint<
+          is_convertible<Executor1, Executor>::value
+      >::type = 0)
+    : service_(other.service_),
+      executor_(other.executor_)
+  {
+    service_->move_construct(impl_, *other.service_, other.impl_);
+  }
+
+  /// Move-assign a basic_concurrent_channel from another.
+  /**
+   * This assignment operator moves a channel from one object to another.
+   * Cancels any outstanding asynchronous operations associated with the target
+   * object.
+   *
+   * @param other The other basic_concurrent_channel object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_concurrent_channel(const executor_type&)
+   * constructor.
+   */
+  template <typename Executor1>
+  typename constraint<
+    is_convertible<Executor1, Executor>::value,
+    basic_concurrent_channel&
+  >::type operator=(
+      basic_concurrent_channel<Executor1, Traits, Signatures...>&& other)
+  {
+    if (this != &other)
+    {
+      service_->move_assign(impl_, *other.service_, other.impl_);
+      executor_.~executor_type();
+      new (&executor_) executor_type(other.executor_);
+      service_ = other.service_;
+    }
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
+
+  /// Destructor.
+  ~basic_concurrent_channel()
+  {
+    service_->destroy(impl_);
+  }
+
+  /// Get the executor associated with the object.
+  executor_type get_executor() BOOST_ASIO_NOEXCEPT
+  {
+    return executor_;
+  }
+
+  /// Get the capacity of the channel's buffer.
+  std::size_t capacity() BOOST_ASIO_NOEXCEPT
+  {
+    return service_->capacity(impl_);
+  }
+
+  /// Determine whether the channel is open.
+  bool is_open() const BOOST_ASIO_NOEXCEPT
+  {
+    return service_->is_open(impl_);
+  }
+
+  /// Reset the channel to its initial state.
+  void reset()
+  {
+    service_->reset(impl_);
+  }
+
+  /// Close the channel.
+  void close()
+  {
+    service_->close(impl_);
+  }
+
+  /// Cancel all asynchronous operations waiting on the channel.
+  /**
+   * All outstanding send operations will complete with the error
+   * @c boost::asio::experimental::error::channel_canceld. Outstanding receive
+   * operations complete with the result as determined by the channel traits.
+   */
+  void cancel()
+  {
+    service_->cancel(impl_);
+  }
+
+  /// Determine whether a message can be received without blocking.
+  bool ready() const BOOST_ASIO_NOEXCEPT
+  {
+    return service_->ready(impl_);
+  }
+
+#if defined(GENERATING_DOCUMENTATION)
+
+  /// Try to send a message without blocking.
+  /**
+   * Fails if the buffer is full and there are no waiting receive operations.
+   *
+   * @returns @c true on success, @c false on failure.
+   */
+  template <typename... Args>
+  bool try_send(BOOST_ASIO_MOVE_ARG(Args)... args);
+
+  /// Try to send a number of messages without blocking.
+  /**
+   * @returns The number of messages that were sent.
+   */
+  template <typename... Args>
+  std::size_t try_send_n(std::size_t count, BOOST_ASIO_MOVE_ARG(Args)... args);
+
+  /// Asynchronously send a message.
+  template <typename... Args,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
+        CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  auto async_send(BOOST_ASIO_MOVE_ARG(Args)... args,
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token);
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+  /// Try to receive a message without blocking.
+  /**
+   * Fails if the buffer is full and there are no waiting receive operations.
+   *
+   * @returns @c true on success, @c false on failure.
+   */
+  template <typename Handler>
+  bool try_receive(BOOST_ASIO_MOVE_ARG(Handler) handler)
+  {
+    return service_->try_receive(impl_, BOOST_ASIO_MOVE_CAST(Handler)(handler));
+  }
+
+  /// Asynchronously receive a message.
+  template <typename CompletionToken
+      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  auto async_receive(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
+#if !defined(GENERATING_DOCUMENTATION)
+    -> decltype(
+        this->do_async_receive(static_cast<payload_type*>(0),
+          BOOST_ASIO_MOVE_CAST(CompletionToken)(token)))
+#endif // !defined(GENERATING_DOCUMENTATION)
+  {
+    return this->do_async_receive(static_cast<payload_type*>(0),
+        BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
+  }
+
+private:
+  // Disallow copying and assignment.
+  basic_concurrent_channel(
+      const basic_concurrent_channel&) BOOST_ASIO_DELETED;
+  basic_concurrent_channel& operator=(
+      const basic_concurrent_channel&) BOOST_ASIO_DELETED;
+
+  template <typename, typename, typename...>
+  friend class detail::channel_send_functions;
+
+  // Helper function to get an executor's context.
+  template <typename T>
+  static execution_context& get_context(const T& t,
+      typename enable_if<execution::is_executor<T>::value>::type* = 0)
+  {
+    return boost::asio::query(t, execution::context);
+  }
+
+  // Helper function to get an executor's context.
+  template <typename T>
+  static execution_context& get_context(const T& t,
+      typename enable_if<!execution::is_executor<T>::value>::type* = 0)
+  {
+    return t.context();
+  }
+
+  class initiate_async_send
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_send(basic_concurrent_channel* self)
+      : self_(self)
+    {
+    }
+
+    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename SendHandler>
+    void operator()(BOOST_ASIO_MOVE_ARG(SendHandler) handler,
+        BOOST_ASIO_MOVE_ARG(payload_type) payload) const
+    {
+      boost::asio::detail::non_const_lvalue<SendHandler> handler2(handler);
+      self_->service_->async_send(self_->impl_,
+          BOOST_ASIO_MOVE_CAST(payload_type)(payload),
+          handler2.value, self_->get_executor());
+    }
+
+  private:
+    basic_concurrent_channel* self_;
+  };
+
+  class initiate_async_receive
+  {
+  public:
+    typedef Executor executor_type;
+
+    explicit initiate_async_receive(basic_concurrent_channel* self)
+      : self_(self)
+    {
+    }
+
+    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return self_->get_executor();
+    }
+
+    template <typename ReceiveHandler>
+    void operator()(BOOST_ASIO_MOVE_ARG(ReceiveHandler) handler) const
+    {
+      boost::asio::detail::non_const_lvalue<ReceiveHandler> handler2(handler);
+      self_->service_->async_receive(self_->impl_,
+          handler2.value, self_->get_executor());
+    }
+
+  private:
+    basic_concurrent_channel* self_;
+  };
+
+  // The service associated with the I/O object.
+  service_type* service_;
+
+  // The underlying implementation of the I/O object.
+  typename service_type::template implementation_type<
+      Traits, Signatures...> impl_;
+
+  // The associated executor.
+  Executor executor_;
+};
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_BASIC_CONCURRENT_CHANNEL_HPP
diff --git a/boost/asio/experimental/cancellation_condition.hpp b/boost/asio/experimental/cancellation_condition.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f6d33effd18a611762bb60e23af7756249428bcc
--- /dev/null
+++ b/boost/asio/experimental/cancellation_condition.hpp
@@ -0,0 +1,157 @@
+//
+// experimental/cancellation_condition.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_CANCELLATION_CONDITION_HPP
+#define BOOST_ASIO_EXPERIMENTAL_CANCELLATION_CONDITION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <exception>
+#include <boost/asio/cancellation_type.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+/// Wait for all operations to complete.
+class wait_for_all
+{
+public:
+  template <typename... Args>
+  BOOST_ASIO_CONSTEXPR cancellation_type_t operator()(
+      Args&&...) const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_type::none;
+  }
+};
+
+/// Wait until an operation completes, then cancel the others.
+class wait_for_one
+{
+public:
+  BOOST_ASIO_CONSTEXPR explicit wait_for_one(
+      cancellation_type_t cancel_type = cancellation_type::all)
+    : cancel_type_(cancel_type)
+  {
+  }
+
+  template <typename... Args>
+  BOOST_ASIO_CONSTEXPR cancellation_type_t operator()(
+      Args&&...) const BOOST_ASIO_NOEXCEPT
+  {
+    return cancel_type_;
+  }
+
+private:
+  cancellation_type_t cancel_type_;
+};
+
+/// Wait until an operation completes without an error, then cancel the others.
+/**
+ * If no operation completes without an error, waits for completion of all
+ * operations.
+ */
+class wait_for_one_success
+{
+public:
+  BOOST_ASIO_CONSTEXPR explicit wait_for_one_success(
+      cancellation_type_t cancel_type = cancellation_type::all)
+    : cancel_type_(cancel_type)
+  {
+  }
+
+  BOOST_ASIO_CONSTEXPR cancellation_type_t
+  operator()() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancel_type_;
+  }
+
+  template <typename E, typename... Args>
+  BOOST_ASIO_CONSTEXPR typename constraint<
+    !is_same<typename decay<E>::type, boost::system::error_code>::value
+      && !is_same<typename decay<E>::type, std::exception_ptr>::value,
+    cancellation_type_t
+  >::type operator()(const E&, Args&&...) const BOOST_ASIO_NOEXCEPT
+  {
+    return cancel_type_;
+  }
+
+  template <typename E, typename... Args>
+  BOOST_ASIO_CONSTEXPR typename constraint<
+      is_same<typename decay<E>::type, boost::system::error_code>::value
+        || is_same<typename decay<E>::type, std::exception_ptr>::value,
+      cancellation_type_t
+  >::type operator()(const E& e, Args&&...) const BOOST_ASIO_NOEXCEPT
+  {
+    return !!e ? cancellation_type::none : cancel_type_;
+  }
+
+private:
+  cancellation_type_t cancel_type_;
+};
+
+/// Wait until an operation completes with an error, then cancel the others.
+/**
+ * If no operation completes with an error, waits for completion of all
+ * operations.
+ */
+class wait_for_one_error
+{
+public:
+  BOOST_ASIO_CONSTEXPR explicit wait_for_one_error(
+      cancellation_type_t cancel_type = cancellation_type::all)
+    : cancel_type_(cancel_type)
+  {
+  }
+
+  BOOST_ASIO_CONSTEXPR cancellation_type_t
+  operator()() const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_type::none;
+  }
+
+  template <typename E, typename... Args>
+  BOOST_ASIO_CONSTEXPR typename constraint<
+    !is_same<typename decay<E>::type, boost::system::error_code>::value
+      && !is_same<typename decay<E>::type, std::exception_ptr>::value,
+    cancellation_type_t
+  >::type operator()(const E&, Args&&...) const BOOST_ASIO_NOEXCEPT
+  {
+    return cancellation_type::none;
+  }
+
+  template <typename E, typename... Args>
+  BOOST_ASIO_CONSTEXPR typename constraint<
+      is_same<typename decay<E>::type, boost::system::error_code>::value
+        || is_same<typename decay<E>::type, std::exception_ptr>::value,
+      cancellation_type_t
+  >::type operator()(const E& e, Args&&...) const BOOST_ASIO_NOEXCEPT
+  {
+    return !!e ? cancel_type_ : cancellation_type::none;
+  }
+
+private:
+  cancellation_type_t cancel_type_;
+};
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_CANCELLATION_CONDITION_HPP
diff --git a/boost/asio/experimental/channel.hpp b/boost/asio/experimental/channel.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..941e5ed32a7daf9fed71879fcc4c9eacce4f46f2
--- /dev/null
+++ b/boost/asio/experimental/channel.hpp
@@ -0,0 +1,72 @@
+//
+// experimental/channel.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_CHANNEL_HPP
+#define BOOST_ASIO_EXPERIMENTAL_CHANNEL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/execution/executor.hpp>
+#include <boost/asio/is_executor.hpp>
+#include <boost/asio/experimental/basic_channel.hpp>
+#include <boost/asio/experimental/channel_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename ExecutorOrSignature, typename = void>
+struct channel_type
+{
+  template <typename... Signatures>
+  struct inner
+  {
+    typedef basic_channel<any_io_executor, channel_traits<>,
+        ExecutorOrSignature, Signatures...> type;
+  };
+};
+
+template <typename ExecutorOrSignature>
+struct channel_type<ExecutorOrSignature,
+    typename enable_if<
+      is_executor<ExecutorOrSignature>::value
+        || execution::is_executor<ExecutorOrSignature>::value
+    >::type>
+{
+  template <typename... Signatures>
+  struct inner
+  {
+    typedef basic_channel<ExecutorOrSignature,
+        channel_traits<>, Signatures...> type;
+  };
+};
+
+} // namespace detail
+
+/// Template type alias for common use of channel.
+template <typename ExecutorOrSignature, typename... Signatures>
+using channel = typename detail::channel_type<
+    ExecutorOrSignature>::template inner<Signatures...>::type;
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_CHANNEL_HPP
diff --git a/boost/asio/experimental/channel_error.hpp b/boost/asio/experimental/channel_error.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..3381c23f646b9960577b4e7d2fa328dcdeaed470
--- /dev/null
+++ b/boost/asio/experimental/channel_error.hpp
@@ -0,0 +1,88 @@
+//
+// experimental/channel_error.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_CHANNEL_ERROR_HPP
+#define BOOST_ASIO_EXPERIMENTAL_CHANNEL_ERROR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/system/error_code.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace error {
+
+enum channel_errors
+{
+  /// The channel was closed.
+  channel_closed = 1,
+
+  /// The channel was cancelled.
+  channel_cancelled = 2
+};
+
+extern BOOST_ASIO_DECL
+const boost::system::error_category& get_channel_category();
+
+static const boost::system::error_category&
+  channel_category BOOST_ASIO_UNUSED_VARIABLE
+  = boost::asio::experimental::error::get_channel_category();
+
+} // namespace error
+namespace channel_errc {
+  // Simulates a scoped enum.
+  using error::channel_closed;
+  using error::channel_cancelled;
+} // namespace channel_errc
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+namespace boost {
+namespace system {
+
+template<> struct is_error_code_enum<
+    boost::asio::experimental::error::channel_errors>
+{
+  static const bool value = true;
+};
+
+} // namespace system
+} // namespace boost
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace error {
+
+inline boost::system::error_code make_error_code(channel_errors e)
+{
+  return boost::system::error_code(
+      static_cast<int>(e), get_channel_category());
+}
+
+} // namespace error
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/experimental/impl/channel_error.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // BOOST_ASIO_EXPERIMENTAL_CHANNEL_ERROR_HPP
diff --git a/boost/asio/experimental/channel_traits.hpp b/boost/asio/experimental/channel_traits.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e259546ddb0298904b5c5d6daa680e181fff8415
--- /dev/null
+++ b/boost/asio/experimental/channel_traits.hpp
@@ -0,0 +1,233 @@
+//
+// experimental/channel_traits.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_CHANNEL_TRAITS_HPP
+#define BOOST_ASIO_EXPERIMENTAL_CHANNEL_TRAITS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <deque>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/experimental/channel_error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+#if defined(GENERATING_DOCUMENTATION)
+
+template <typename... Signatures>
+struct channel_traits
+{
+  /// Rebind the traits to a new set of signatures.
+  /**
+   * This nested structure must have a single nested type @c other that
+   * aliases a traits type with the specified set of signatures.
+   */
+  template <typename... NewSignatures>
+  struct rebind
+  {
+    typedef user_defined other;
+  };
+
+  /// Determine the container for the specified elements.
+  /**
+   * This nested structure must have a single nested type @c other that
+   * aliases a container type for the specified element type.
+   */
+  template <typename Element>
+  struct container
+  {
+    typedef user_defined type;
+  };
+
+  /// The signature of a channel cancellation notification.
+  typedef void receive_cancelled_signature(...);
+
+  /// Invoke the specified handler with a cancellation notification.
+  template <typename F>
+  static void invoke_receive_cancelled(F f);
+
+  /// The signature of a channel closed notification.
+  typedef void receive_closed_signature(...);
+
+  /// Invoke the specified handler with a closed notification.
+  template <typename F>
+  static void invoke_receive_closed(F f);
+};
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+/// Traits used for customising channel behaviour.
+template <typename... Signatures>
+struct channel_traits
+{
+  template <typename... NewSignatures>
+  struct rebind
+  {
+    typedef channel_traits<NewSignatures...> other;
+  };
+};
+
+template <typename R, typename... Args, typename... Signatures>
+struct channel_traits<R(boost::system::error_code, Args...), Signatures...>
+{
+  template <typename... NewSignatures>
+  struct rebind
+  {
+    typedef channel_traits<NewSignatures...> other;
+  };
+
+  template <typename Element>
+  struct container
+  {
+    typedef std::deque<Element> type;
+  };
+
+  typedef R receive_cancelled_signature(boost::system::error_code, Args...);
+
+  template <typename F>
+  static void invoke_receive_cancelled(F f)
+  {
+    const boost::system::error_code e = error::channel_cancelled;
+    BOOST_ASIO_MOVE_OR_LVALUE(F)(f)(e, typename decay<Args>::type()...);
+  }
+
+  typedef R receive_closed_signature(boost::system::error_code, Args...);
+
+  template <typename F>
+  static void invoke_receive_closed(F f)
+  {
+    const boost::system::error_code e = error::channel_closed;
+    BOOST_ASIO_MOVE_OR_LVALUE(F)(f)(e, typename decay<Args>::type()...);
+  }
+};
+
+template <typename R, typename... Args, typename... Signatures>
+struct channel_traits<R(std::exception_ptr, Args...), Signatures...>
+{
+  template <typename... NewSignatures>
+  struct rebind
+  {
+    typedef channel_traits<NewSignatures...> other;
+  };
+
+  template <typename Element>
+  struct container
+  {
+    typedef std::deque<Element> type;
+  };
+
+  typedef R receive_cancelled_signature(std::exception_ptr, Args...);
+
+  template <typename F>
+  static void invoke_receive_cancelled(F f)
+  {
+    const boost::system::error_code e = error::channel_cancelled;
+    BOOST_ASIO_MOVE_OR_LVALUE(F)(f)(
+        std::make_exception_ptr(boost::system::system_error(e)),
+        typename decay<Args>::type()...);
+  }
+
+  typedef R receive_closed_signature(std::exception_ptr, Args...);
+
+  template <typename F>
+  static void invoke_receive_closed(F f)
+  {
+    const boost::system::error_code e = error::channel_closed;
+    BOOST_ASIO_MOVE_OR_LVALUE(F)(f)(
+        std::make_exception_ptr(boost::system::system_error(e)),
+        typename decay<Args>::type()...);
+  }
+};
+
+template <typename R>
+struct channel_traits<R()>
+{
+  template <typename... NewSignatures>
+  struct rebind
+  {
+    typedef channel_traits<NewSignatures...> other;
+  };
+
+  template <typename Element>
+  struct container
+  {
+    typedef std::deque<Element> type;
+  };
+
+  typedef R receive_cancelled_signature(boost::system::error_code);
+
+  template <typename F>
+  static void invoke_receive_cancelled(F f)
+  {
+    const boost::system::error_code e = error::channel_cancelled;
+    BOOST_ASIO_MOVE_OR_LVALUE(F)(f)(e);
+  }
+
+  typedef R receive_closed_signature(boost::system::error_code);
+
+  template <typename F>
+  static void invoke_receive_closed(F f)
+  {
+    const boost::system::error_code e = error::channel_closed;
+    BOOST_ASIO_MOVE_OR_LVALUE(F)(f)(e);
+  }
+};
+
+template <typename R, typename T>
+struct channel_traits<R(T)>
+{
+  template <typename... NewSignatures>
+  struct rebind
+  {
+    typedef channel_traits<NewSignatures...> other;
+  };
+
+  template <typename Element>
+  struct container
+  {
+    typedef std::deque<Element> type;
+  };
+
+  typedef R receive_cancelled_signature(boost::system::error_code);
+
+  template <typename F>
+  static void invoke_receive_cancelled(F f)
+  {
+    const boost::system::error_code e = error::channel_cancelled;
+    BOOST_ASIO_MOVE_OR_LVALUE(F)(f)(e);
+  }
+
+  typedef R receive_closed_signature(boost::system::error_code);
+
+  template <typename F>
+  static void invoke_receive_closed(F f)
+  {
+    const boost::system::error_code e = error::channel_closed;
+    BOOST_ASIO_MOVE_OR_LVALUE(F)(f)(e);
+  }
+};
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_CHANNEL_TRAITS_HPP
diff --git a/boost/asio/experimental/co_spawn.hpp b/boost/asio/experimental/co_spawn.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c973c61cbef2faa9e65628d8f9eec11c3498690a
--- /dev/null
+++ b/boost/asio/experimental/co_spawn.hpp
@@ -0,0 +1,189 @@
+//
+// experimental/co_spawn.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_ASIO_EXPERIMENTAL_CO_SPAWN_HPP
+#define BOOST_ASIO_EXPERIMENTAL_CO_SPAWN_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <utility>
+#include <boost/asio/compose.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/experimental/coro.hpp>
+#include <boost/asio/experimental/deferred.hpp>
+#include <boost/asio/experimental/prepend.hpp>
+#include <boost/asio/redirect_error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename T, typename U, typename Executor>
+struct coro_spawn_op
+{
+  coro<T, U, Executor> c;
+
+  void operator()(auto& self)
+  {
+    auto op = c.async_resume(deferred);
+    std::move(op)((prepend)(std::move(self), 0));
+  }
+
+  void operator()(auto& self, int, auto... res)
+  {
+    self.complete(std::move(res)...);
+  }
+};
+
+} // namespace detail
+
+/// Spawn a resumable coroutine.
+/**
+ * This function spawns the coroutine for execution on its executor. It binds
+ * the lifetime of the coroutine to the executor.
+ *
+ * @param c The coroutine
+ *
+ * @param token The completion token
+ *
+ * @returns Implementation defined
+ */
+template <typename T, typename Executor, typename CompletionToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
+    CompletionToken, void(std::exception_ptr, T))
+co_spawn(coro<void, T, Executor> c, CompletionToken&& token)
+{
+  auto exec = c.get_executor();
+  return async_compose<CompletionToken, void(std::exception_ptr, T)>(
+      detail::coro_spawn_op<void, T, Executor>{std::move(c)},
+      token, exec);
+}
+
+/// Spawn a resumable coroutine.
+/**
+ * This function spawns the coroutine for execution on its executor. It binds
+ * the lifetime of the coroutine to the executor.
+ *
+ * @param c The coroutine
+ *
+ * @param token The completion token
+ *
+ * @returns Implementation defined
+ */
+template <typename T, typename Executor, typename CompletionToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
+    CompletionToken, void(std::exception_ptr, T))
+co_spawn(coro<void(), T, Executor> c, CompletionToken&& token)
+{
+  auto exec = c.get_executor();
+  return async_compose<CompletionToken, void(std::exception_ptr, T)>(
+      detail::coro_spawn_op<void(), T, Executor>{std::move(c)},
+      token, exec);
+}
+
+/// Spawn a resumable coroutine.
+/**
+ * This function spawns the coroutine for execution on its executor. It binds
+ * the lifetime of the coroutine to the executor.
+ *
+ * @param c The coroutine
+ *
+ * @param token The completion token
+ *
+ * @returns Implementation defined
+ */
+template <typename T, typename Executor, typename CompletionToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void(T))
+co_spawn(coro<void() noexcept, T, Executor> c, CompletionToken&& token)
+{
+  auto exec = c.get_executor();
+  return async_compose<CompletionToken, void(T)>(
+      detail::coro_spawn_op<void() noexcept, T, Executor>{std::move(c)},
+      token, exec);
+}
+
+/// Spawn a resumable coroutine.
+/**
+ * This function spawns the coroutine for execution on its executor. It binds
+ * the lifetime of the coroutine to the executor.
+ *
+ * @param c The coroutine
+ *
+ * @param token The completion token
+ *
+ * @returns Implementation defined
+ */
+template <typename Executor, typename CompletionToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
+    CompletionToken, void(std::exception_ptr))
+co_spawn(coro<void, void, Executor> c, CompletionToken&& token)
+{
+  auto exec = c.get_executor();
+  return async_compose<CompletionToken, void(std::exception_ptr)>(
+      detail::coro_spawn_op<void, void, Executor>{std::move(c)},
+      token, exec);
+}
+
+/// Spawn a resumable coroutine.
+/**
+ * This function spawns the coroutine for execution on its executor. It binds
+ * the lifetime of the coroutine to the executor.
+ *
+ * @param c The coroutine
+ *
+ * @param token The completion token
+ *
+ * @returns Implementation defined
+ */
+template <typename Executor, typename CompletionToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(
+    CompletionToken, void(std::exception_ptr))
+co_spawn(coro<void(), void, Executor> c, CompletionToken&& token)
+{
+  auto exec = c.get_executor();
+  return async_compose<CompletionToken, void(std::exception_ptr)>(
+      detail::coro_spawn_op<void(), void, Executor>{std::move(c)},
+      token, exec);
+}
+
+/// Spawn a resumable coroutine.
+/**
+ * This function spawns the coroutine for execution on its executor. It binds
+ * the lifetime of the coroutine to the executor.
+ *
+ * @param c The coroutine
+ *
+ * @param token The completion token
+ *
+ * @returns Implementation defined
+ */
+template <typename Executor, typename CompletionToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void())
+co_spawn(coro<void() noexcept, void, Executor> c, CompletionToken&& token)
+{
+  auto exec = c.get_executor();
+  return async_compose<CompletionToken, void()>(
+      detail::coro_spawn_op<void() noexcept, void, Executor>{std::move(c)},
+      token, exec);
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif //BOOST_ASIO_EXPERIMENTAL_CO_SPAWN_HPP
diff --git a/boost/asio/experimental/concurrent_channel.hpp b/boost/asio/experimental/concurrent_channel.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c32367a9f42e51b6587e3905c5d8e83f7c2f668e
--- /dev/null
+++ b/boost/asio/experimental/concurrent_channel.hpp
@@ -0,0 +1,72 @@
+//
+// experimental/concurrent_channel.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_CONCURRENT_CHANNEL_HPP
+#define BOOST_ASIO_EXPERIMENTAL_CONCURRENT_CHANNEL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/execution/executor.hpp>
+#include <boost/asio/is_executor.hpp>
+#include <boost/asio/experimental/basic_concurrent_channel.hpp>
+#include <boost/asio/experimental/channel_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename ExecutorOrSignature, typename = void>
+struct concurrent_channel_type
+{
+  template <typename... Signatures>
+  struct inner
+  {
+    typedef basic_concurrent_channel<any_io_executor, channel_traits<>,
+        ExecutorOrSignature, Signatures...> type;
+  };
+};
+
+template <typename ExecutorOrSignature>
+struct concurrent_channel_type<ExecutorOrSignature,
+    typename enable_if<
+      is_executor<ExecutorOrSignature>::value
+        || execution::is_executor<ExecutorOrSignature>::value
+    >::type>
+{
+  template <typename... Signatures>
+  struct inner
+  {
+    typedef basic_concurrent_channel<ExecutorOrSignature,
+        channel_traits<>, Signatures...> type;
+  };
+};
+
+} // namespace detail
+
+/// Template type alias for common use of channel.
+template <typename ExecutorOrSignature, typename... Signatures>
+using concurrent_channel = typename detail::concurrent_channel_type<
+    ExecutorOrSignature>::template inner<Signatures...>::type;
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_CONCURRENT_CHANNEL_HPP
diff --git a/boost/asio/experimental/coro.hpp b/boost/asio/experimental/coro.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f32bf00aadce2dfa05efee96a7252a6be0ddb3cf
--- /dev/null
+++ b/boost/asio/experimental/coro.hpp
@@ -0,0 +1,265 @@
+//
+// experimental/coro.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_CORO_HPP
+#define BOOST_ASIO_EXPERIMENTAL_CORO_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/dispatch.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/asio/experimental/coro_traits.hpp>
+#include <boost/asio/experimental/detail/coro_promise_allocator.hpp>
+#include <boost/asio/experimental/detail/partial_promise.hpp>
+#include <boost/asio/experimental/use_coro.hpp>
+#include <boost/asio/post.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename T, typename Coroutine>
+struct coro_with_arg;
+
+} // namespace detail
+
+/// The main type of a resumable coroutine.
+/**
+ * Template parameter @c Yield specifies type or signature used by co_yield,
+ * @c Return specifies the type used for co_return, and @c Executor specifies
+ * the underlying executor type.
+ */
+template <typename Yield = void, typename Return = void,
+    typename Executor = any_io_executor>
+struct coro
+{
+  /// The traits of the coroutine. See boost::asio::experimental::coro_traits
+  /// for details.
+  using traits = coro_traits<Yield, Return, Executor>;
+
+  /// The value that can be passed into a symmetrical cororoutine. @c void if
+  /// asymmetrical.
+  using input_type = typename traits::input_type;
+
+  /// The type that can be passed out through a co_yield.
+  using yield_type = typename traits::yield_type;
+
+  /// The type that can be passed out through a co_return.
+  using return_type = typename traits::return_type;
+
+  /// The type received by a co_await or async_resume. Its a combination of
+  /// yield and return.
+  using result_type = typename traits::result_type;
+
+  /// The signature used by the async_resume.
+  using signature_type = typename traits::signature_type;
+
+  /// Whether or not the coroutine is noexcept.
+  constexpr static bool is_noexcept = traits::is_noexcept;
+
+  /// The error type of the coroutine. Void for noexcept
+  using error_type = typename traits::error_type;
+
+  /// Completion handler type used by async_resume.
+  using completion_handler = typename traits::completion_handler;
+
+  /// The internal promise-type of the coroutine.
+  using promise_type = detail::coro_promise<Yield, Return, Executor>;
+
+#if !defined(GENERATING_DOCUMENTATION)
+  template <typename T, typename Coroutine>
+  friend struct detail::coro_with_arg;
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+  /// The executor type.
+  using executor_type = Executor;
+
+#if !defined(GENERATING_DOCUMENTATION)
+  friend struct detail::coro_promise<Yield, Return, Executor>;
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+  /// The default constructor, gives an invalid coroutine.
+  coro() = default;
+
+  /// Move constructor.
+  coro(coro&& lhs) noexcept
+    : coro_(std::exchange(lhs.coro_, nullptr))
+  {
+  }
+
+  coro(const coro &) = delete;
+
+  /// Move assignment.
+  coro& operator=(coro&& lhs) noexcept
+  {
+    std::swap(coro_, lhs.coro_);
+    return *this;
+  }
+
+  coro& operator=(const coro&) = delete;
+
+  /// Destructor. Destroys the coroutine, if it holds a valid one.
+  /**
+   * @note This does not cancel an active coroutine. Destructing a resumable
+   * coroutine, i.e. one with a call to async_resume that has not completed, is
+   * undefined behaviour.
+   */
+  ~coro()
+  {
+    if (coro_ != nullptr)
+    {
+      struct destroyer
+      {
+        detail::coroutine_handle<promise_type> handle;
+
+        destroyer(const detail::coroutine_handle<promise_type>& handle)
+          : handle(handle)
+        { }
+
+        destroyer(destroyer&& lhs)
+          : handle(std::exchange(lhs.handle, nullptr))
+        {
+        }
+
+        destroyer(const destroyer&) = delete;
+
+        void operator()() {}
+
+        ~destroyer()
+        {
+          if (handle)
+            handle.destroy();
+        }
+      };
+
+      auto handle =
+        detail::coroutine_handle<promise_type>::from_promise(*coro_);
+      if (handle)
+        boost::asio::dispatch(coro_->get_executor(), destroyer{handle});
+    }
+  }
+
+  /// Get the used executor.
+  executor_type get_executor() const
+  {
+    if (coro_)
+      return coro_->get_executor();
+
+    if constexpr (std::is_default_constructible_v<Executor>)
+      return Executor{};
+    else
+      throw std::logic_error("Coroutine has no executor");
+  }
+
+  /// Resume the coroutine.
+  /**
+   * @param token The completion token of the async resume.
+   *
+   * @attention Calling an invalid coroutine with a noexcept signature is
+   * undefined behaviour.
+   *
+   * @note This overload is only available for coroutines without an input
+   * value.
+   */
+  template <typename CompletionToken>
+    requires std::is_void_v<input_type>
+  auto async_resume(CompletionToken&& token) &
+  {
+    return async_initiate<CompletionToken,
+        typename traits::completion_handler>(
+          initiate_async_resume(this), token);
+  }
+
+  /// Resume the coroutine.
+  /**
+   * @param token The completion token of the async resume.
+   *
+   * @attention Calling an invalid coroutine with a noexcept signature is
+   * undefined behaviour.
+   *
+   * @note This overload is only available for coroutines with an input value.
+   */
+  template <typename CompletionToken, detail::convertible_to<input_type> T>
+  auto async_resume(T&& ip, CompletionToken&& token) &
+  {
+    return async_initiate<CompletionToken,
+        typename traits::completion_handler>(
+          initiate_async_resume(this), token, std::forward<T>(ip));
+  }
+
+  /// Operator used for coroutines without input value.
+  auto operator co_await() requires (std::is_void_v<input_type>)
+  {
+    return awaitable_t{*this};
+  }
+
+  /// Operator used for coroutines with input value.
+  /**
+   * @param ip The input value
+   *
+   * @returns An awaitable handle.
+   *
+   * @code
+   * coro<void> push_values(coro<double(int)> c)
+   * {
+   *    std::optional<double> res = co_await c(42);
+   * }
+   * @endcode
+   */
+  template <detail::convertible_to<input_type> T>
+  auto operator()(T&& ip)
+  {
+    return detail::coro_with_arg<std::decay_t<T>, coro>{
+        std::forward<T>(ip), *this};
+  }
+
+  /// Check whether the coroutine is open, i.e. can be resumed.
+  bool is_open() const
+  {
+    if (coro_)
+    {
+      auto handle =
+        detail::coroutine_handle<promise_type>::from_promise(*coro_);
+      return handle && !handle.done();
+    }
+    else
+      return false;
+  }
+
+  /// Check whether the coroutine is open, i.e. can be resumed.
+  explicit operator bool() const { return is_open(); }
+
+private:
+  struct awaitable_t;
+
+  struct initiate_async_resume;
+
+  explicit coro(promise_type* const cr) : coro_(cr) {}
+
+  promise_type* coro_{nullptr};
+};
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/experimental/impl/coro.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_CORO_HPP
diff --git a/boost/asio/experimental/coro_traits.hpp b/boost/asio/experimental/coro_traits.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..bcd92aad527a52837cbf2a65937c99ac1e2f9bc8
--- /dev/null
+++ b/boost/asio/experimental/coro_traits.hpp
@@ -0,0 +1,230 @@
+//
+// experimental/detail/coro_traits.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_CORO_TRAITS_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_CORO_TRAITS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <optional>
+#include <variant>
+#include <boost/asio/any_io_executor.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <class From, class To>
+concept convertible_to = std::is_convertible_v<From, To>;
+
+template <typename T>
+concept decays_to_executor = execution::executor<std::decay_t<T>>;
+
+template <typename T, typename Executor = any_io_executor>
+concept execution_context = requires (T& t)
+{
+  {t.get_executor()} -> convertible_to<Executor>;
+};
+
+template <typename Yield, typename Return>
+struct coro_result
+{
+  using type = std::variant<Yield, Return>;
+};
+
+template <typename Yield>
+struct coro_result<Yield, void>
+{
+  using type = std::optional<Yield>;
+};
+
+template <typename Return>
+struct coro_result<void, Return>
+{
+  using type = Return;
+};
+
+template <typename YieldReturn>
+struct coro_result<YieldReturn, YieldReturn>
+{
+  using type = YieldReturn;
+};
+
+template <>
+struct coro_result<void, void>
+{
+  using type = void;
+};
+
+template <typename Yield, typename Return>
+using coro_result_t = typename coro_result<Yield, Return>::type;
+
+template <typename Result, bool IsNoexcept>
+struct coro_handler;
+
+template <>
+struct coro_handler<void, false>
+{
+  using type = void(std::exception_ptr);
+};
+
+template <>
+struct coro_handler<void, true>
+{
+  using type = void();
+};
+
+template <typename T>
+struct coro_handler<T, false>
+{
+  using type = void(std::exception_ptr, T);
+};
+
+template <typename T>
+struct coro_handler<T, true>
+{
+  using type = void(T);
+};
+
+template <typename Result, bool IsNoexcept>
+using coro_handler_t = typename coro_handler<Result, IsNoexcept>::type;
+
+} // namespace detail
+
+#if defined(GENERATING_DOCUMENTATION)
+
+/// The traits describing the resumable coroutine behaviour.
+/**
+ * Template parameter @c Yield specifies type or signature used by co_yield,
+ * @c Return specifies the type used for co_return, and @c Executor specifies
+ * the underlying executor type.
+ */
+template <typename Yield, typename Return, typename Executor>
+struct coro_traits
+{
+  /// The value that can be passed into a symmetrical cororoutine. @c void if
+  /// asymmetrical.
+  using input_type = argument_dependent;
+
+  /// The type that can be passed out through a co_yield.
+  using yield_type = argument_dependent;
+
+  /// The type that can be passed out through a co_return.
+  using return_type = argument_dependent;
+
+  /// The type received by a co_await or async_resume. It's a combination of
+  /// yield and return.
+  using result_type = argument_dependent;
+
+  /// The signature used by the async_resume.
+  using signature_type = argument_dependent;
+
+  /// Whether or not the coroutine is noexcept.
+  constexpr static bool is_noexcept = argument_dependent;
+
+  /// The error type of the coroutine. @c void for noexcept.
+  using error_type = argument_dependent;
+
+  /// Completion handler type used by async_resume.
+  using completion_handler = argument_dependent;
+};
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+template <typename Yield, typename Return, typename Executor>
+struct coro_traits
+{
+  using input_type  = void;
+  using yield_type  = Yield;
+  using return_type = Return;
+  using result_type = detail::coro_result_t<yield_type, return_type>;
+  using signature_type = result_type();
+  constexpr static bool is_noexcept = false;
+  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
+  using completion_handler = detail::coro_handler_t<result_type, is_noexcept>;
+};
+
+template <typename T, typename Return, typename Executor>
+struct coro_traits<T(), Return, Executor>
+{
+  using input_type = void;
+  using yield_type = T;
+  using return_type = Return;
+  using result_type = detail::coro_result_t<yield_type, return_type>;
+  using signature_type = result_type();
+  constexpr static bool is_noexcept = false;
+  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
+  using completion_handler = detail::coro_handler_t<result_type, is_noexcept>;
+};
+
+template <typename T, typename Return, typename Executor>
+struct coro_traits<T() noexcept, Return, Executor>
+{
+  using input_type = void;
+  using yield_type = T;
+  using return_type = Return;
+  using result_type = detail::coro_result_t<yield_type, return_type>;
+  using signature_type = result_type();
+  constexpr static bool is_noexcept = true;
+  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
+  using completion_handler = detail::coro_handler_t<result_type, is_noexcept>;
+};
+
+template <typename T, typename U, typename Return, typename Executor>
+struct coro_traits<T(U), Return, Executor>
+{
+  using input_type = U;
+  using yield_type = T;
+  using return_type = Return;
+  using result_type = detail::coro_result_t<yield_type, return_type>;
+  using signature_type = result_type(input_type);
+  constexpr static bool is_noexcept = false;
+  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
+  using completion_handler = detail::coro_handler_t<result_type, is_noexcept>;
+};
+
+template <typename T, typename U, typename Return, typename Executor>
+struct coro_traits<T(U) noexcept, Return, Executor>
+{
+  using input_type = U;
+  using yield_type = T;
+  using return_type = Return;
+  using result_type = detail::coro_result_t<yield_type, return_type>;
+  using signature_type = result_type(input_type);
+  constexpr static bool is_noexcept = true;
+  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
+  using completion_handler = detail::coro_handler_t<result_type, is_noexcept>;
+};
+
+template <typename Executor>
+struct coro_traits<void() noexcept, void, Executor>
+{
+  using input_type = void;
+  using yield_type = void;
+  using return_type = void;
+  using result_type = detail::coro_result_t<yield_type, return_type>;
+  using signature_type = result_type(input_type);
+  constexpr static bool is_noexcept = true;
+  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
+  using completion_handler = detail::coro_handler_t<result_type, is_noexcept>;
+};
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_CORO_TRAITS_HPP
diff --git a/boost/asio/experimental/deferred.hpp b/boost/asio/experimental/deferred.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a8a79467ef0dc6a97cff6445ea02d837aabdfdf2
--- /dev/null
+++ b/boost/asio/experimental/deferred.hpp
@@ -0,0 +1,607 @@
+//
+// experimental/deferred.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DEFERRED_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DEFERRED_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <tuple>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+/// Trait for detecting objects that are usable as deferred operations.
+template <typename T>
+struct is_deferred : false_type
+{
+};
+
+namespace detail {
+
+// Helper trait for getting the completion signature from an async operation.
+
+struct deferred_signature_probe {};
+
+template <typename T>
+struct deferred_signature_probe_result
+{
+  typedef T type;
+};
+
+template <typename T>
+struct deferred_signature
+{
+  typedef typename decltype(
+      declval<T>()(declval<deferred_signature_probe>()))::type type;
+};
+
+// Helper trait for getting the completion signature of the tail in a sequence
+// when invoked with the specified arguments.
+
+template <typename HeadSignature, typename Tail>
+struct deferred_sequence_signature;
+
+template <typename R, typename... Args, typename Tail>
+struct deferred_sequence_signature<R(Args...), Tail>
+{
+  static_assert(
+      !is_same<decltype(declval<Tail>()(declval<Args>()...)), void>::value,
+      "deferred functions must produce a deferred return type");
+
+  typedef typename decltype(
+      declval<Tail>()(declval<Args>()...)(
+        declval<deferred_signature_probe>()))::type type;
+};
+
+// Completion handler for the head component of a deferred sequence.
+template <typename Handler, typename Tail>
+class deferred_sequence_handler
+{
+public:
+  template <typename H, typename T>
+  explicit deferred_sequence_handler(
+      BOOST_ASIO_MOVE_ARG(H) handler, BOOST_ASIO_MOVE_ARG(T) tail)
+    : handler_(BOOST_ASIO_MOVE_CAST(H)(handler)),
+      tail_(BOOST_ASIO_MOVE_CAST(T)(tail))
+  {
+  }
+
+  template <typename... Args>
+  void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Tail)(tail_)(
+        BOOST_ASIO_MOVE_CAST(Args)(args)...)(
+          BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_));
+  }
+
+//private:
+  Handler handler_;
+  Tail tail_;
+};
+
+} // namespace detail
+
+/// Used to represent an empty deferred action.
+struct deferred_noop
+{
+  /// No effect.
+  template <typename... Args>
+  void operator()(BOOST_ASIO_MOVE_ARG(Args)...) BOOST_ASIO_RVALUE_REF_QUAL
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  /// No effect.
+  template <typename... Args>
+  decltype(auto) operator()(BOOST_ASIO_MOVE_ARG(Args)...) const &
+  {
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <>
+struct is_deferred<deferred_noop> : true_type
+{
+};
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Tag type to disambiguate deferred constructors.
+struct deferred_init_tag {};
+
+/// Wraps a function object so that it may be used as an element in a deferred
+/// composition.
+template <typename Function>
+class deferred_function
+{
+public:
+  /// Constructor. 
+  template <typename F>
+  BOOST_ASIO_CONSTEXPR explicit deferred_function(
+      deferred_init_tag, BOOST_ASIO_MOVE_ARG(F) function)
+    : function_(BOOST_ASIO_MOVE_CAST(F)(function))
+  {
+  }
+
+  template <typename... Args>
+  decltype(auto) operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args) BOOST_ASIO_RVALUE_REF_QUAL
+  {
+    return BOOST_ASIO_MOVE_CAST(Function)(function_)(
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <typename... Args>
+  decltype(auto) operator()(
+      BOOST_ASIO_MOVE_ARG(Args)... args) const &
+  {
+    return deferred_function(*this)(
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+//private:
+  Function function_;
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <typename Function>
+struct is_deferred<deferred_function<Function> > : true_type
+{
+};
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Encapsulates deferred values.
+template <typename... Values>
+class BOOST_ASIO_NODISCARD deferred_values
+{
+private:
+  std::tuple<Values...> values_;
+
+  struct initiate
+  {
+    template <typename Handler, typename... V>
+    void operator()(Handler handler, BOOST_ASIO_MOVE_ARG(V)... values)
+    {
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(
+          BOOST_ASIO_MOVE_CAST(V)(values)...);
+    }
+  };
+
+  template <typename CompletionToken, std::size_t... I>
+  decltype(auto) invoke_helper(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+      std::index_sequence<I...>)
+  {
+    return boost::asio::async_initiate<CompletionToken, void(Values...)>(
+        initiate(), token,
+        std::get<I>(BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(values_))...);
+  }
+
+public:
+  /// Construct a deferred asynchronous operation from the arguments to an
+  /// initiation function object.
+  template <typename... V>
+  BOOST_ASIO_CONSTEXPR explicit deferred_values(
+      deferred_init_tag, BOOST_ASIO_MOVE_ARG(V)... values)
+    : values_(BOOST_ASIO_MOVE_CAST(V)(values)...)
+  {
+  }
+
+  /// Initiate the deferred operation using the supplied completion token.
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void(Values...)) CompletionToken>
+  decltype(auto) operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) BOOST_ASIO_RVALUE_REF_QUAL
+  {
+    return this->invoke_helper(
+        BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+        std::index_sequence_for<Values...>());
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void(Values...)) CompletionToken>
+  decltype(auto) operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) const &
+  {
+    return deferred_values(*this)(
+        BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <typename... Values>
+struct is_deferred<deferred_values<Values...> > : true_type
+{
+};
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Encapsulates a deferred asynchronous operation.
+template <typename Signature, typename Initiation, typename... InitArgs>
+class BOOST_ASIO_NODISCARD deferred_async_operation
+{
+private:
+  typename decay<Initiation>::type initiation_;
+  typedef std::tuple<typename decay<InitArgs>::type...> init_args_t;
+  init_args_t init_args_;
+
+  template <typename CompletionToken, std::size_t... I>
+  decltype(auto) invoke_helper(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+      std::index_sequence<I...>)
+  {
+    return boost::asio::async_initiate<CompletionToken, Signature>(
+        BOOST_ASIO_MOVE_CAST(typename decay<Initiation>::type)(initiation_),
+        token, std::get<I>(BOOST_ASIO_MOVE_CAST(init_args_t)(init_args_))...);
+  }
+
+public:
+  /// Construct a deferred asynchronous operation from the arguments to an
+  /// initiation function object.
+  template <typename I, typename... A>
+  BOOST_ASIO_CONSTEXPR explicit deferred_async_operation(
+      deferred_init_tag, BOOST_ASIO_MOVE_ARG(I) initiation,
+      BOOST_ASIO_MOVE_ARG(A)... init_args)
+    : initiation_(BOOST_ASIO_MOVE_CAST(I)(initiation)),
+      init_args_(BOOST_ASIO_MOVE_CAST(A)(init_args)...)
+  {
+  }
+
+  /// Initiate the asynchronous operation using the supplied completion token.
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signature) CompletionToken>
+  decltype(auto) operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) BOOST_ASIO_RVALUE_REF_QUAL
+  {
+    return this->invoke_helper(
+        BOOST_ASIO_MOVE_CAST(CompletionToken)(token),
+        std::index_sequence_for<InitArgs...>());
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(Signature) CompletionToken>
+  decltype(auto) operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) const &
+  {
+    return deferred_async_operation(*this)(
+        BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <typename Signature, typename Initiation, typename... InitArgs>
+struct is_deferred<
+    deferred_async_operation<Signature, Initiation, InitArgs...> > : true_type
+{
+};
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Defines a link between two consecutive operations in a sequence.
+template <typename Head, typename Tail>
+class BOOST_ASIO_NODISCARD deferred_sequence
+{
+private:
+  typedef typename detail::deferred_sequence_signature<
+    typename detail::deferred_signature<Head>::type, Tail>::type
+      signature;
+
+public:
+  template <typename H, typename T>
+  BOOST_ASIO_CONSTEXPR explicit deferred_sequence(deferred_init_tag,
+      BOOST_ASIO_MOVE_ARG(H) head, BOOST_ASIO_MOVE_ARG(T) tail)
+    : head_(BOOST_ASIO_MOVE_CAST(H)(head)),
+      tail_(BOOST_ASIO_MOVE_CAST(T)(tail))
+  {
+  }
+
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(signature) CompletionToken>
+  decltype(auto) operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) BOOST_ASIO_RVALUE_REF_QUAL
+  {
+    return boost::asio::async_initiate<CompletionToken, signature>(
+        initiate(), token, BOOST_ASIO_MOVE_OR_LVALUE(Head)(head_),
+        BOOST_ASIO_MOVE_OR_LVALUE(Tail)(tail_));
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(signature) CompletionToken>
+  decltype(auto) operator()(
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token) const &
+  {
+    return deferred_sequence(*this)(
+        BOOST_ASIO_MOVE_CAST(CompletionToken)(token));
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+private:
+  struct initiate
+  {
+    template <typename Handler>
+    void operator()(BOOST_ASIO_MOVE_ARG(Handler) handler,
+        Head head, BOOST_ASIO_MOVE_ARG(Tail) tail)
+    {
+      BOOST_ASIO_MOVE_OR_LVALUE(Head)(head)(
+          detail::deferred_sequence_handler<
+            typename decay<Handler>::type,
+            typename decay<Tail>::type>(
+              BOOST_ASIO_MOVE_CAST(Handler)(handler),
+              BOOST_ASIO_MOVE_CAST(Tail)(tail)));
+    }
+  };
+
+  Head head_;
+  Tail tail_;
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <typename Head, typename Tail>
+struct is_deferred<deferred_sequence<Head, Tail> > : true_type
+{
+};
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Used to represent a deferred conditional branch.
+template <typename OnTrue = deferred_noop,
+    typename OnFalse = deferred_noop>
+class BOOST_ASIO_NODISCARD deferred_conditional
+{
+public:
+  /// Construct a deferred conditional with the value to determine which branch
+  /// will be executed.
+  BOOST_ASIO_CONSTEXPR explicit deferred_conditional(bool b)
+    : on_true_(),
+      on_false_(),
+      bool_(b)
+  {
+  }
+
+  /// Invoke the conditional branch bsaed on the stored alue.
+  template <typename... Args>
+  auto operator()(BOOST_ASIO_MOVE_ARG(Args)... args) BOOST_ASIO_RVALUE_REF_QUAL
+  {
+    if (bool_)
+    {
+      return BOOST_ASIO_MOVE_OR_LVALUE(OnTrue)(on_true_)(
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+    else
+    {
+      return BOOST_ASIO_MOVE_OR_LVALUE(OnFalse)(on_false_)(
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+  }
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+  template <typename... Args>
+  auto operator()(BOOST_ASIO_MOVE_ARG(Args)... args) const &
+  {
+    return deferred_conditional(*this)(
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+  /// Set the true branch of the conditional.
+  template <typename T>
+  deferred_conditional<T, OnFalse> then(T on_true,
+      typename constraint<
+        is_deferred<T>::value
+      >::type* = 0,
+      typename constraint<
+        is_same<
+          typename conditional<true, OnTrue, T>::type,
+          deferred_noop
+        >::value
+      >::type* = 0) BOOST_ASIO_RVALUE_REF_QUAL
+  {
+    return deferred_conditional<T, OnFalse>(
+        bool_, BOOST_ASIO_MOVE_CAST(T)(on_true),
+        BOOST_ASIO_MOVE_CAST(OnFalse)(on_false_));
+  }
+
+  /// Set the false branch of the conditional.
+  template <typename T>
+  deferred_conditional<OnTrue, T> otherwise(T on_false,
+      typename constraint<
+        is_deferred<T>::value
+      >::type* = 0,
+      typename constraint<
+        !is_same<
+          typename conditional<true, OnTrue, T>::type,
+          deferred_noop
+        >::value
+      >::type* = 0,
+      typename constraint<
+        is_same<
+          typename conditional<true, OnFalse, T>::type,
+          deferred_noop
+        >::value
+      >::type* = 0) BOOST_ASIO_RVALUE_REF_QUAL
+  {
+    return deferred_conditional<OnTrue, T>(
+        bool_, BOOST_ASIO_MOVE_CAST(OnTrue)(on_true_),
+        BOOST_ASIO_MOVE_CAST(T)(on_false));
+  }
+
+private:
+  template <typename T, typename F> friend class deferred_conditional;
+
+  // Helper constructor.
+  template <typename T, typename F>
+  explicit deferred_conditional(bool b, BOOST_ASIO_MOVE_ARG(T) on_true,
+      BOOST_ASIO_MOVE_ARG(F) on_false)
+    : on_true_(BOOST_ASIO_MOVE_CAST(T)(on_true)),
+      on_false_(BOOST_ASIO_MOVE_CAST(F)(on_false)),
+      bool_(b)
+  {
+  }
+
+  OnTrue on_true_;
+  OnFalse on_false_;
+  bool bool_;
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+template <typename OnTrue, typename OnFalse>
+struct is_deferred<deferred_conditional<OnTrue, OnFalse> > : true_type
+{
+};
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Class used to specify that an asynchronous operation should return a
+/// function object to lazily launch the operation.
+/**
+ * The deferred_t class is used to indicate that an asynchronous operation
+ * should return a function object which is itself an initiation function. A
+ * deferred_t object may be passed as a completion token to an asynchronous
+ * operation, typically using the special value @c boost::asio::deferred. For
+ * example:
+ *
+ * @code auto my_sender
+ *   = my_socket.async_read_some(my_buffer,
+ *       boost::asio::experimental::deferred); @endcode
+ *
+ * The initiating function (async_read_some in the above example) returns a
+ * function object that will lazily initiate the operation.
+ */
+class deferred_t
+{
+public:
+  /// Default constructor.
+  BOOST_ASIO_CONSTEXPR deferred_t()
+  {
+  }
+
+  /// Adapts an executor to add the @c deferred_t completion token as the
+  /// default.
+  template <typename InnerExecutor>
+  struct executor_with_default : InnerExecutor
+  {
+    /// Specify @c deferred_t as the default completion token type.
+    typedef deferred_t default_completion_token_type;
+
+    /// Construct the adapted executor from the inner executor type.
+    template <typename InnerExecutor1>
+    executor_with_default(const InnerExecutor1& ex,
+        typename constraint<
+          conditional<
+            !is_same<InnerExecutor1, executor_with_default>::value,
+            is_convertible<InnerExecutor1, InnerExecutor>,
+            false_type
+          >::type::value
+        >::type = 0) BOOST_ASIO_NOEXCEPT
+      : InnerExecutor(ex)
+    {
+    }
+  };
+
+  /// Type alias to adapt an I/O object to use @c deferred_t as its
+  /// default completion token type.
+#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES) \
+  || defined(GENERATING_DOCUMENTATION)
+  template <typename T>
+  using as_default_on_t = typename T::template rebind_executor<
+      executor_with_default<typename T::executor_type> >::other;
+#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+  /// Function helper to adapt an I/O object to use @c deferred_t as its
+  /// default completion token type.
+  template <typename T>
+  static typename decay<T>::type::template rebind_executor<
+      executor_with_default<typename decay<T>::type::executor_type>
+    >::other
+  as_default_on(BOOST_ASIO_MOVE_ARG(T) object)
+  {
+    return typename decay<T>::type::template rebind_executor<
+        executor_with_default<typename decay<T>::type::executor_type>
+      >::other(BOOST_ASIO_MOVE_CAST(T)(object));
+  }
+
+  /// Creates a new deferred from a function.
+  template <typename Function>
+  typename constraint<
+    !is_deferred<typename decay<Function>::type>::value,
+    deferred_function<typename decay<Function>::type>
+  >::type operator()(BOOST_ASIO_MOVE_ARG(Function) function) const
+  {
+    return deferred_function<typename decay<Function>::type>(
+        deferred_init_tag{}, BOOST_ASIO_MOVE_CAST(Function)(function));
+  }
+
+  /// Passes through anything that is already deferred.
+  template <typename T>
+  typename constraint<
+    is_deferred<typename decay<T>::type>::value,
+    typename decay<T>::type
+  >::type operator()(BOOST_ASIO_MOVE_ARG(T) t) const
+  {
+    return BOOST_ASIO_MOVE_CAST(T)(t);
+  }
+
+  /// Returns a deferred operation that returns the provided values.
+  template <typename... Args>
+  static BOOST_ASIO_CONSTEXPR deferred_values<typename decay<Args>::type...>
+  values(BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return deferred_values<typename decay<Args>::type...>(
+        deferred_init_tag{}, BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+  /// Creates a conditional object for branching deferred operations.
+  static BOOST_ASIO_CONSTEXPR deferred_conditional<> when(bool b)
+  {
+    return deferred_conditional<>(b);
+  }
+};
+
+/// Pipe operator used to chain deferred operations.
+template <typename Head, typename Tail>
+inline auto operator|(Head head, BOOST_ASIO_MOVE_ARG(Tail) tail)
+  -> typename constraint<
+      is_deferred<Head>::value,
+      decltype(BOOST_ASIO_MOVE_OR_LVALUE(Head)(head)(
+            BOOST_ASIO_MOVE_CAST(Tail)(tail)))
+    >::type
+{
+  return BOOST_ASIO_MOVE_OR_LVALUE(Head)(head)(
+      BOOST_ASIO_MOVE_CAST(Tail)(tail));
+}
+
+/// A special value, similar to std::nothrow.
+/**
+ * See the documentation for boost::asio::experimental::deferred_t for a usage
+ * example.
+ */
+#if defined(BOOST_ASIO_HAS_CONSTEXPR) || defined(GENERATING_DOCUMENTATION)
+constexpr deferred_t deferred;
+#elif defined(BOOST_ASIO_MSVC)
+__declspec(selectany) deferred_t deferred;
+#endif
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/experimental/impl/deferred.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DEFERRED_HPP
diff --git a/boost/asio/experimental/detail/channel_handler.hpp b/boost/asio/experimental/detail/channel_handler.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..84d6dfb972d0fbaf51e081b91d398839538fb1fd
--- /dev/null
+++ b/boost/asio/experimental/detail/channel_handler.hpp
@@ -0,0 +1,72 @@
+//
+// experimental/detail/channel_handler.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_HANDLER_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_HANDLER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/experimental/detail/channel_payload.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename Payload, typename Handler>
+class channel_handler
+{
+public:
+  channel_handler(BOOST_ASIO_MOVE_ARG(Payload) p, Handler& h)
+    : payload_(BOOST_ASIO_MOVE_CAST(Payload)(p)),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(h))
+  {
+  }
+
+  void operator()()
+  {
+    payload_.receive(handler_);
+  }
+
+//private:
+  Payload payload_;
+  Handler handler_;
+};
+
+} // namespace detail
+} // namespace experimental
+
+template <template <typename, typename> class Associator,
+    typename Payload, typename Handler, typename DefaultCandidate>
+struct associator<Associator,
+    experimental::detail::channel_handler<Payload, Handler>,
+    DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const experimental::detail::channel_handler<Payload, Handler>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_HANDLER_HPP
diff --git a/boost/asio/experimental/detail/channel_message.hpp b/boost/asio/experimental/detail/channel_message.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f565c7e313e338d1f5af0651718a8d25c34975ef
--- /dev/null
+++ b/boost/asio/experimental/detail/channel_message.hpp
@@ -0,0 +1,124 @@
+//
+// experimental/detail/channel_message.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_MESSAGE_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_MESSAGE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <tuple>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename Signature>
+class channel_message;
+
+template <typename R>
+class channel_message<R()>
+{
+public:
+  channel_message(int)
+  {
+  }
+
+  template <typename Handler>
+  void receive(Handler& handler)
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)();
+  }
+};
+
+template <typename R, typename Arg0>
+class channel_message<R(Arg0)>
+{
+public:
+  template <typename T0>
+  channel_message(int, BOOST_ASIO_MOVE_ARG(T0) t0)
+    : arg0_(BOOST_ASIO_MOVE_CAST(T0)(t0))
+  {
+  }
+
+  template <typename Handler>
+  void receive(Handler& handler)
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(
+        BOOST_ASIO_MOVE_CAST(arg0_type)(arg0_));
+  }
+
+private:
+  typedef typename decay<Arg0>::type arg0_type;
+  arg0_type arg0_;
+};
+
+template <typename R, typename Arg0, typename Arg1>
+class channel_message<R(Arg0, Arg1)>
+{
+public:
+  template <typename T0, typename T1>
+  channel_message(int, BOOST_ASIO_MOVE_ARG(T0) t0, BOOST_ASIO_MOVE_ARG(T1) t1)
+    : arg0_(BOOST_ASIO_MOVE_CAST(T0)(t0)),
+      arg1_(BOOST_ASIO_MOVE_CAST(T1)(t1))
+  {
+  }
+
+  template <typename Handler>
+  void receive(Handler& handler)
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(
+        BOOST_ASIO_MOVE_CAST(arg0_type)(arg0_),
+        BOOST_ASIO_MOVE_CAST(arg1_type)(arg1_));
+  }
+
+private:
+  typedef typename decay<Arg0>::type arg0_type;
+  arg0_type arg0_;
+  typedef typename decay<Arg1>::type arg1_type;
+  arg1_type arg1_;
+};
+
+template <typename R, typename... Args>
+class channel_message<R(Args...)>
+{
+public:
+  template <typename... T>
+  channel_message(int, BOOST_ASIO_MOVE_ARG(T)... t)
+    : args_(BOOST_ASIO_MOVE_CAST(T)(t)...)
+  {
+  }
+
+  template <typename Handler>
+  void receive(Handler& h)
+  {
+    std::apply(BOOST_ASIO_MOVE_OR_LVALUE(Handler)(h),
+        BOOST_ASIO_MOVE_CAST(args_type)(args_));
+  }
+
+private:
+  typedef std::tuple<typename decay<Args>::type...> args_type;
+  args_type args_;
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_MESSAGE_HPP
diff --git a/boost/asio/experimental/detail/channel_operation.hpp b/boost/asio/experimental/detail/channel_operation.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f2a2907ce0fdd088d367513f5a61dd66f18273d9
--- /dev/null
+++ b/boost/asio/experimental/detail/channel_operation.hpp
@@ -0,0 +1,201 @@
+//
+// experimental/detail/channel_operation.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_OPERATION_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_OPERATION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/detail/op_queue.hpp>
+#include <boost/asio/execution/executor.hpp>
+#include <boost/asio/execution/outstanding_work.hpp>
+#include <boost/asio/executor_work_guard.hpp>
+#include <boost/asio/prefer.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+// Base class for all channel operations. A function pointer is used instead of
+// virtual functions to avoid the associated overhead.
+class channel_operation BOOST_ASIO_INHERIT_TRACKED_HANDLER
+{
+public:
+  template <typename Executor, typename = void>
+  class handler_work_base;
+
+  template <typename Handler, typename IoExecutor, typename = void>
+  class handler_work;
+
+  void destroy()
+  {
+    func_(this, destroy_op, 0);
+  }
+
+protected:
+  enum action
+  {
+    destroy_op = 0,
+    complete_op = 1,
+    cancel_op = 2,
+    close_op = 3
+  };
+
+  typedef void (*func_type)(channel_operation*, action, void*);
+
+  channel_operation(func_type func)
+    : next_(0),
+      func_(func),
+      cancellation_key_(0)
+  {
+  }
+
+  // Prevents deletion through this type.
+  ~channel_operation()
+  {
+  }
+
+  friend class boost::asio::detail::op_queue_access;
+  channel_operation* next_;
+  func_type func_;
+
+public:
+  // The operation key used for targeted cancellation.
+  void* cancellation_key_;
+};
+
+template <typename Executor, typename>
+class channel_operation::handler_work_base
+{
+public:
+  handler_work_base(int, const Executor& ex)
+    : executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked))
+  {
+  }
+
+  template <typename Function, typename Handler>
+  void post(Function& function, Handler& handler)
+  {
+    typename associated_allocator<Handler>::type allocator =
+      (get_associated_allocator)(handler);
+
+    execution::execute(
+        boost::asio::prefer(
+          boost::asio::require(executor_, execution::blocking.never),
+          execution::allocator(allocator)),
+        BOOST_ASIO_MOVE_CAST(Function)(function));
+  }
+
+private:
+  typename decay<
+      typename prefer_result<Executor,
+        execution::outstanding_work_t::tracked_t
+      >::type
+    >::type executor_;
+};
+
+#if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
+
+template <typename Executor>
+class channel_operation::handler_work_base<Executor,
+    typename enable_if<
+      !execution::is_executor<Executor>::value
+    >::type>
+{
+public:
+  handler_work_base(int, const Executor& ex)
+    : work_(ex)
+  {
+  }
+
+  template <typename Function, typename Handler>
+  void post(Function& function, Handler& handler)
+  {
+    typename associated_allocator<Handler>::type allocator =
+      (get_associated_allocator)(handler);
+
+    work_.get_executor().post(
+        BOOST_ASIO_MOVE_CAST(Function)(function), allocator);
+  }
+
+private:
+  executor_work_guard<Executor> work_;
+};
+
+#endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS)
+
+template <typename Handler, typename IoExecutor, typename>
+class channel_operation::handler_work :
+  channel_operation::handler_work_base<IoExecutor>,
+  channel_operation::handler_work_base<
+      typename associated_executor<Handler, IoExecutor>::type, IoExecutor>
+{
+public:
+  typedef channel_operation::handler_work_base<IoExecutor> base1_type;
+
+  typedef channel_operation::handler_work_base<
+      typename associated_executor<Handler, IoExecutor>::type, IoExecutor>
+    base2_type;
+
+  handler_work(Handler& handler, const IoExecutor& io_ex) BOOST_ASIO_NOEXCEPT
+    : base1_type(0, io_ex),
+      base2_type(0, (get_associated_executor)(handler, io_ex))
+  {
+  }
+
+  template <typename Function>
+  void complete(Function& function, Handler& handler)
+  {
+    base2_type::post(function, handler);
+  }
+};
+
+template <typename Handler, typename IoExecutor>
+class channel_operation::handler_work<
+    Handler, IoExecutor,
+    typename enable_if<
+      is_same<
+        typename associated_executor<Handler,
+          IoExecutor>::asio_associated_executor_is_unspecialised,
+        void
+      >::value
+    >::type> : handler_work_base<IoExecutor>
+{
+public:
+  typedef channel_operation::handler_work_base<IoExecutor> base1_type;
+
+  handler_work(Handler&, const IoExecutor& io_ex) BOOST_ASIO_NOEXCEPT
+    : base1_type(0, io_ex)
+  {
+  }
+
+  template <typename Function>
+  void complete(Function& function, Handler& handler)
+  {
+    base1_type::post(function, handler);
+  }
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_OPERATION_HPP
diff --git a/boost/asio/experimental/detail/channel_payload.hpp b/boost/asio/experimental/detail/channel_payload.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..83415322e5b0a46f504876cfee19ba02c720ea50
--- /dev/null
+++ b/boost/asio/experimental/detail/channel_payload.hpp
@@ -0,0 +1,95 @@
+//
+// experimental/detail/channel_payload.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_PAYLOAD_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_PAYLOAD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <variant>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/experimental/detail/channel_message.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename... Signatures>
+class channel_payload
+{
+public:
+  template <typename Signature>
+  channel_payload(BOOST_ASIO_MOVE_ARG(channel_message<Signature>) m)
+    : message_(BOOST_ASIO_MOVE_CAST(channel_message<Signature>)(m))
+  {
+  }
+
+  template <typename Handler>
+  void receive(Handler& handler)
+  {
+    std::visit(
+        [&](auto& message)
+        {
+          message.receive(handler);
+        }, message_);
+  }
+
+private:
+  std::variant<channel_message<Signatures>...> message_;
+};
+
+template <typename R>
+class channel_payload<R()>
+{
+public:
+  explicit channel_payload(channel_message<R()>)
+  {
+  }
+
+  template <typename Handler>
+  void receive(Handler& handler)
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)();
+  }
+};
+
+template <typename Signature>
+class channel_payload<Signature>
+{
+public:
+  channel_payload(BOOST_ASIO_MOVE_ARG(channel_message<Signature>) m)
+    : message_(BOOST_ASIO_MOVE_CAST(channel_message<Signature>)(m))
+  {
+  }
+
+  template <typename Handler>
+  void receive(Handler& handler)
+  {
+    message_.receive(handler);
+  }
+
+private:
+  channel_message<Signature> message_;
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_PAYLOAD_HPP
diff --git a/boost/asio/experimental/detail/channel_receive_op.hpp b/boost/asio/experimental/detail/channel_receive_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..4c3f04cad17b63e5eae9f5192e6f984c9c1504bf
--- /dev/null
+++ b/boost/asio/experimental/detail/channel_receive_op.hpp
@@ -0,0 +1,114 @@
+//
+// experimental/detail/channel_receive_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_RECEIVE_OP_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_RECEIVE_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/experimental/detail/channel_handler.hpp>
+#include <boost/asio/experimental/detail/channel_operation.hpp>
+#include <boost/asio/experimental/detail/channel_payload.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename Payload>
+class channel_receive : public channel_operation
+{
+public:
+  void complete(Payload payload)
+  {
+    func_(this, complete_op, &payload);
+  }
+
+protected:
+  channel_receive(func_type func)
+    : channel_operation(func)
+  {
+  }
+};
+
+template <typename Payload, typename Handler, typename IoExecutor>
+class channel_receive_op : public channel_receive<Payload>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(channel_receive_op);
+
+  template <typename... Args>
+  channel_receive_op(Handler& handler, const IoExecutor& io_ex)
+    : channel_receive<Payload>(&channel_receive_op::do_action),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_action(channel_operation* base,
+      channel_operation::action a, void* v)
+  {
+    // Take ownership of the operation object.
+    channel_receive_op* o(static_cast<channel_receive_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    channel_operation::handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(channel_operation::handler_work<
+          Handler, IoExecutor>)(o->work_));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the handler is posted. Even if we're not about to post the handler, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    if (a == channel_operation::complete_op)
+    {
+      Payload* payload = static_cast<Payload*>(v);
+      channel_handler<Payload, Handler> handler(
+          BOOST_ASIO_MOVE_CAST(Payload)(*payload), o->handler_);
+      p.h = boost::asio::detail::addressof(handler.handler_);
+      p.reset();
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN(());
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+    else
+    {
+      boost::asio::detail::binder0<Handler> handler(o->handler_);
+      p.h = boost::asio::detail::addressof(handler.handler_);
+      p.reset();
+    }
+  }
+
+private:
+  Handler handler_;
+  channel_operation::handler_work<Handler, IoExecutor> work_;
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_RECEIVE_OP_HPP
diff --git a/boost/asio/experimental/detail/channel_send_functions.hpp b/boost/asio/experimental/detail/channel_send_functions.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..7b6c24bc86535586fa193ca919fa840b2c43ed51
--- /dev/null
+++ b/boost/asio/experimental/detail/channel_send_functions.hpp
@@ -0,0 +1,134 @@
+//
+// experimental/detail/channel_send_functions.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SEND_FUNCTIONS_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SEND_FUNCTIONS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/asio/experimental/detail/channel_message.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename Derived, typename Executor, typename... Signatures>
+class channel_send_functions;
+
+template <typename Derived, typename Executor, typename R, typename... Args>
+class channel_send_functions<Derived, Executor, R(Args...)>
+{
+public:
+  template <typename... Args2>
+  typename enable_if<
+    is_constructible<detail::channel_message<R(Args...)>, int, Args2...>::value,
+    bool
+  >::type try_send(BOOST_ASIO_MOVE_ARG(Args2)... args)
+  {
+    typedef typename detail::channel_message<R(Args...)> message_type;
+    Derived* self = static_cast<Derived*>(this);
+    return self->service_->template try_send<message_type>(
+        self->impl_, BOOST_ASIO_MOVE_CAST(Args2)(args)...);
+  }
+
+  template <typename... Args2>
+  typename enable_if<
+    is_constructible<detail::channel_message<R(Args...)>, int, Args2...>::value,
+    std::size_t
+  >::type try_send_n(std::size_t count, BOOST_ASIO_MOVE_ARG(Args2)... args)
+  {
+    typedef typename detail::channel_message<R(Args...)> message_type;
+    Derived* self = static_cast<Derived*>(this);
+    return self->service_->template try_send_n<message_type>(
+        self->impl_, count, BOOST_ASIO_MOVE_CAST(Args2)(args)...);
+  }
+
+  template <
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
+        CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+  auto async_send(Args... args,
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
+  {
+    typedef typename Derived::payload_type payload_type;
+    typedef typename detail::channel_message<R(Args...)> message_type;
+    Derived* self = static_cast<Derived*>(this);
+    return async_initiate<CompletionToken, void (boost::system::error_code)>(
+        typename Derived::initiate_async_send(self), token,
+        payload_type(message_type(0, BOOST_ASIO_MOVE_CAST(Args)(args)...)));
+  }
+};
+
+template <typename Derived, typename Executor,
+    typename R, typename... Args, typename... Signatures>
+class channel_send_functions<Derived, Executor, R(Args...), Signatures...> :
+  public channel_send_functions<Derived, Executor, Signatures...>
+{
+public:
+  using channel_send_functions<Derived, Executor, Signatures...>::try_send;
+  using channel_send_functions<Derived, Executor, Signatures...>::async_send;
+
+  template <typename... Args2>
+  typename enable_if<
+    is_constructible<detail::channel_message<R(Args...)>, int, Args2...>::value,
+    bool
+  >::type try_send(BOOST_ASIO_MOVE_ARG(Args2)... args)
+  {
+    typedef typename detail::channel_message<R(Args...)> message_type;
+    Derived* self = static_cast<Derived*>(this);
+    return self->service_->template try_send<message_type>(
+        self->impl_, BOOST_ASIO_MOVE_CAST(Args2)(args)...);
+  }
+
+  template <typename... Args2>
+  typename enable_if<
+    is_constructible<detail::channel_message<R(Args...)>, int, Args2...>::value,
+    std::size_t
+  >::type try_send_n(std::size_t count, BOOST_ASIO_MOVE_ARG(Args2)... args)
+  {
+    typedef typename detail::channel_message<R(Args...)> message_type;
+    Derived* self = static_cast<Derived*>(this);
+    return self->service_->template try_send_n<message_type>(
+        self->impl_, count, BOOST_ASIO_MOVE_CAST(Args2)(args)...);
+  }
+
+  template <
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
+        CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+  auto async_send(Args... args,
+      BOOST_ASIO_MOVE_ARG(CompletionToken) token
+        BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
+  {
+    typedef typename Derived::payload_type payload_type;
+    typedef typename detail::channel_message<R(Args...)> message_type;
+    Derived* self = static_cast<Derived*>(this);
+    return async_initiate<CompletionToken, void (boost::system::error_code)>(
+        typename Derived::initiate_async_send(self), token,
+        payload_type(message_type(0, BOOST_ASIO_MOVE_CAST(Args)(args)...)));
+  }
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SEND_FUNCTIONS_HPP
diff --git a/boost/asio/experimental/detail/channel_send_op.hpp b/boost/asio/experimental/detail/channel_send_op.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..3961236964a76883946be82cd3abdf04b2ca5b15
--- /dev/null
+++ b/boost/asio/experimental/detail/channel_send_op.hpp
@@ -0,0 +1,142 @@
+//
+// experimental/detail/channel_send_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SEND_OP_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SEND_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/experimental/channel_error.hpp>
+#include <boost/asio/experimental/detail/channel_operation.hpp>
+#include <boost/asio/experimental/detail/channel_payload.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename Payload>
+class channel_send : public channel_operation
+{
+public:
+  Payload get_payload()
+  {
+    return BOOST_ASIO_MOVE_CAST(Payload)(payload_);
+  }
+
+  void complete()
+  {
+    func_(this, complete_op, 0);
+  }
+
+  void cancel()
+  {
+    func_(this, cancel_op, 0);
+  }
+
+  void close()
+  {
+    func_(this, close_op, 0);
+  }
+
+protected:
+  channel_send(func_type func, BOOST_ASIO_MOVE_ARG(Payload) payload)
+    : channel_operation(func),
+      payload_(BOOST_ASIO_MOVE_CAST(Payload)(payload))
+  {
+  }
+
+private:
+  Payload payload_;
+};
+
+template <typename Payload, typename Handler, typename IoExecutor>
+class channel_send_op : public channel_send<Payload>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(channel_send_op);
+
+  channel_send_op(BOOST_ASIO_MOVE_ARG(Payload) payload,
+      Handler& handler, const IoExecutor& io_ex)
+    : channel_send<Payload>(&channel_send_op::do_action,
+        BOOST_ASIO_MOVE_CAST(Payload)(payload)),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      work_(handler_, io_ex)
+  {
+  }
+
+  static void do_action(channel_operation* base,
+      channel_operation::action a, void*)
+  {
+    // Take ownership of the operation object.
+    channel_send_op* o(static_cast<channel_send_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+    // Take ownership of the operation's outstanding work.
+    channel_operation::handler_work<Handler, IoExecutor> w(
+        BOOST_ASIO_MOVE_CAST2(channel_operation::handler_work<
+          Handler, IoExecutor>)(o->work_));
+
+    boost::system::error_code ec;
+    switch (a)
+    {
+    case channel_operation::cancel_op:
+      ec = error::channel_cancelled;
+      break;
+    case channel_operation::close_op:
+      ec = error::channel_closed;
+      break;
+    default:
+      break;
+    }
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the handler is posted. Even if we're not about to post the handler, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    boost::asio::detail::binder1<Handler, boost::system::error_code>
+      handler(o->handler_, ec);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Post the completion if required.
+    if (a != channel_operation::destroy_op)
+    {
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
+      w.complete(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+  channel_operation::handler_work<Handler, IoExecutor> work_;
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SEND_OP_HPP
diff --git a/boost/asio/experimental/detail/channel_service.hpp b/boost/asio/experimental/detail/channel_service.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f8520a4ef32c3111f6cdaa61b6f9b5063007f84a
--- /dev/null
+++ b/boost/asio/experimental/detail/channel_service.hpp
@@ -0,0 +1,499 @@
+//
+// experimental/detail/channel_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SERVICE_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/cancellation_type.hpp>
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/op_queue.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/experimental/detail/channel_message.hpp>
+#include <boost/asio/experimental/detail/channel_receive_op.hpp>
+#include <boost/asio/experimental/detail/channel_send_op.hpp>
+#include <boost/asio/experimental/detail/has_signature.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename Mutex>
+class channel_service
+  : public boost::asio::detail::execution_context_service_base<
+      channel_service<Mutex> >
+{
+public:
+  // Possible states for a channel end.
+  enum state
+  {
+    buffer = 0,
+    waiter = 1,
+    block = 2,
+    closed = 3
+  };
+
+  // The base implementation type of all channels.
+  struct base_implementation_type
+  {
+    // Default constructor.
+    base_implementation_type()
+      : receive_state_(block),
+        send_state_(block),
+        max_buffer_size_(0),
+        next_(0),
+        prev_(0)
+    {
+    }
+
+    // The current state of the channel.
+    state receive_state_ : 16;
+    state send_state_ : 16;
+
+    // The maximum number of elements that may be buffered in the channel.
+    std::size_t max_buffer_size_;
+
+    // The operations that are waiting on the channel.
+    boost::asio::detail::op_queue<channel_operation> waiters_;
+
+    // Pointers to adjacent channel implementations in linked list.
+    base_implementation_type* next_;
+    base_implementation_type* prev_;
+
+    // The mutex type to protect the internal implementation.
+    mutable Mutex mutex_;
+  };
+
+  // The implementation for a specific value type.
+  template <typename Traits, typename... Signatures>
+  struct implementation_type;
+
+  // Constructor.
+  channel_service(execution_context& ctx);
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown();
+
+  // Construct a new channel implementation.
+  void construct(base_implementation_type& impl, std::size_t max_buffer_size);
+
+  // Destroy a channel implementation.
+  template <typename Traits, typename... Signatures>
+  void destroy(implementation_type<Traits, Signatures...>& impl);
+
+  // Move-construct a new channel implementation.
+  template <typename Traits, typename... Signatures>
+  void move_construct(implementation_type<Traits, Signatures...>& impl,
+      implementation_type<Traits, Signatures...>& other_impl);
+
+  // Move-assign from another channel implementation.
+  template <typename Traits, typename... Signatures>
+  void move_assign(implementation_type<Traits, Signatures...>& impl,
+      channel_service& other_service,
+      implementation_type<Traits, Signatures...>& other_impl);
+
+  // Get the capacity of the channel.
+  std::size_t capacity(
+      const base_implementation_type& impl) const BOOST_ASIO_NOEXCEPT;
+
+  // Determine whether the channel is open.
+  bool is_open(const base_implementation_type& impl) const BOOST_ASIO_NOEXCEPT;
+
+  // Reset the channel to its initial state.
+  template <typename Traits, typename... Signatures>
+  void reset(implementation_type<Traits, Signatures...>& impl);
+
+  // Close the channel.
+  template <typename Traits, typename... Signatures>
+  void close(implementation_type<Traits, Signatures...>& impl);
+
+  // Cancel all operations associated with the channel.
+  template <typename Traits, typename... Signatures>
+  void cancel(implementation_type<Traits, Signatures...>& impl);
+
+  // Cancel the operation associated with the channel that has the given key.
+  template <typename Traits, typename... Signatures>
+  void cancel_by_key(implementation_type<Traits, Signatures...>& impl,
+      void* cancellation_key);
+
+  // Determine whether a value can be read from the channel without blocking.
+  bool ready(const base_implementation_type& impl) const BOOST_ASIO_NOEXCEPT;
+
+  // Synchronously send a new value into the channel.
+  template <typename Message, typename Traits,
+      typename... Signatures, typename... Args>
+  bool try_send(implementation_type<Traits, Signatures...>& impl,
+      BOOST_ASIO_MOVE_ARG(Args)... args);
+
+  // Synchronously send a number of new values into the channel.
+  template <typename Message, typename Traits,
+      typename... Signatures, typename... Args>
+  std::size_t try_send_n(implementation_type<Traits, Signatures...>& impl,
+      std::size_t count, BOOST_ASIO_MOVE_ARG(Args)... args);
+
+  // Asynchronously send a new value into the channel.
+  template <typename Traits, typename... Signatures,
+      typename Handler, typename IoExecutor>
+  void async_send(implementation_type<Traits, Signatures...>& impl,
+      BOOST_ASIO_MOVE_ARG2(typename implementation_type<
+        Traits, Signatures...>::payload_type) payload,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef channel_send_op<
+      typename implementation_type<Traits, Signatures...>::payload_type,
+        Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST2(typename implementation_type<
+          Traits, Signatures...>::payload_type)(payload), handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<op_cancellation<Traits, Signatures...> >(
+            this, &impl);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((this->context(), *p.p,
+          "channel", &impl, 0, "async_send"));
+
+    start_send_op(impl, p.p);
+    p.v = p.p = 0;
+  }
+
+  // Synchronously receive a value from the channel.
+  template <typename Traits, typename... Signatures, typename Handler>
+  bool try_receive(implementation_type<Traits, Signatures...>& impl,
+      BOOST_ASIO_MOVE_ARG(Handler) handler);
+
+  // Asynchronously send a new value into the channel.
+  // Asynchronously receive a value from the channel.
+  template <typename Traits, typename... Signatures,
+      typename Handler, typename IoExecutor>
+  void async_receive(implementation_type<Traits, Signatures...>& impl,
+      Handler& handler, const IoExecutor& io_ex)
+  {
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef channel_receive_op<
+      typename implementation_type<Traits, Signatures...>::payload_type,
+        Handler, IoExecutor> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(handler, io_ex);
+
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<op_cancellation<Traits, Signatures...> >(
+            this, &impl);
+    }
+
+    BOOST_ASIO_HANDLER_CREATION((this->context(), *p.p,
+          "channel", &impl, 0, "async_receive"));
+
+    start_receive_op(impl, p.p);
+    p.v = p.p = 0;
+  }
+
+private:
+  // Helper function object to handle a closed notification.
+  template <typename Payload, typename Signature>
+  struct complete_receive
+  {
+    explicit complete_receive(channel_receive<Payload>* op)
+      : op_(op)
+    {
+    }
+
+    template <typename... Args>
+    void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
+    {
+      op_->complete(
+          channel_message<Signature>(0,
+            BOOST_ASIO_MOVE_CAST(Args)(args)...));
+    }
+
+    channel_receive<Payload>* op_;
+  };
+
+  // Destroy a base channel implementation.
+  void base_destroy(base_implementation_type& impl);
+
+  // Helper function to start an asynchronous put operation.
+  template <typename Traits, typename... Signatures>
+  void start_send_op(implementation_type<Traits, Signatures...>& impl,
+      channel_send<typename implementation_type<
+        Traits, Signatures...>::payload_type>* send_op);
+
+  // Helper function to start an asynchronous get operation.
+  template <typename Traits, typename... Signatures>
+  void start_receive_op(implementation_type<Traits, Signatures...>& impl,
+      channel_receive<typename implementation_type<
+        Traits, Signatures...>::payload_type>* receive_op);
+
+  // Helper class used to implement per-operation cancellation.
+  template <typename Traits, typename... Signatures>
+  class op_cancellation
+  {
+  public:
+    op_cancellation(channel_service* s,
+        implementation_type<Traits, Signatures...>* impl)
+      : service_(s),
+        impl_(impl)
+    {
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+      if (!!(type &
+            (cancellation_type::terminal
+              | cancellation_type::partial
+              | cancellation_type::total)))
+      {
+        service_->cancel_by_key(*impl_, this);
+      }
+    }
+
+  private:
+    channel_service* service_;
+    implementation_type<Traits, Signatures...>* impl_;
+  };
+
+  // Mutex to protect access to the linked list of implementations.
+  boost::asio::detail::mutex mutex_;
+
+  // The head of a linked list of all implementations.
+  base_implementation_type* impl_list_;
+};
+
+// The implementation for a specific value type.
+template <typename Mutex>
+template <typename Traits, typename... Signatures>
+struct channel_service<Mutex>::implementation_type : base_implementation_type
+{
+  // The traits type associated with the channel.
+  typedef typename Traits::template rebind<Signatures...>::other traits_type;
+
+  // Type of an element stored in the buffer.
+  typedef typename conditional<
+      has_signature<
+        typename traits_type::receive_cancelled_signature,
+        Signatures...
+      >::value,
+      typename conditional<
+        has_signature<
+          typename traits_type::receive_closed_signature,
+          Signatures...
+        >::value,
+        channel_payload<Signatures...>,
+        channel_payload<
+          Signatures...,
+          typename traits_type::receive_closed_signature
+        >
+      >::type,
+      typename conditional<
+        has_signature<
+          typename traits_type::receive_closed_signature,
+          Signatures...,
+          typename traits_type::receive_cancelled_signature
+        >::value,
+        channel_payload<
+          Signatures...,
+          typename traits_type::receive_cancelled_signature
+        >,
+        channel_payload<
+          Signatures...,
+          typename traits_type::receive_cancelled_signature,
+          typename traits_type::receive_closed_signature
+        >
+      >::type
+    >::type payload_type;
+
+  // Move from another buffer.
+  void buffer_move_from(implementation_type& other)
+  {
+    buffer_ = BOOST_ASIO_MOVE_CAST(
+        typename traits_type::template container<
+          payload_type>::type)(other.buffer_);
+    other.buffer_clear();
+  }
+
+  // Get number of buffered elements.
+  std::size_t buffer_size() const
+  {
+    return buffer_.size();
+  }
+
+  // Push a new value to the back of the buffer.
+  void buffer_push(payload_type payload)
+  {
+    buffer_.push_back(BOOST_ASIO_MOVE_CAST(payload_type)(payload));
+  }
+
+  // Push new values to the back of the buffer.
+  std::size_t buffer_push_n(std::size_t count, payload_type payload)
+  {
+    std::size_t i = 0;
+    for (; i < count && buffer_.size() < this->max_buffer_size_; ++i)
+      buffer_.push_back(payload);
+    return i;
+  }
+
+  // Get the element at the front of the buffer.
+  payload_type buffer_front()
+  {
+    return BOOST_ASIO_MOVE_CAST(payload_type)(buffer_.front());
+  }
+
+  // Pop a value from the front of the buffer.
+  void buffer_pop()
+  {
+    buffer_.pop_front();
+  }
+
+  // Clear all buffered values.
+  void buffer_clear()
+  {
+    buffer_.clear();
+  }
+
+private:
+  // Buffered values.
+  typename traits_type::template container<payload_type>::type buffer_;
+};
+
+// The implementation for a void value type.
+template <typename Mutex>
+template <typename Traits, typename R>
+struct channel_service<Mutex>::implementation_type<Traits, R()>
+  : channel_service::base_implementation_type
+{
+  // The traits type associated with the channel.
+  typedef typename Traits::template rebind<R()>::other traits_type;
+
+  // Type of an element stored in the buffer.
+  typedef typename conditional<
+      has_signature<
+        typename traits_type::receive_cancelled_signature,
+        R()
+      >::value,
+      typename conditional<
+        has_signature<
+          typename traits_type::receive_closed_signature,
+          R()
+        >::value,
+        channel_payload<R()>,
+        channel_payload<
+          R(),
+          typename traits_type::receive_closed_signature
+        >
+      >::type,
+      typename conditional<
+        has_signature<
+          typename traits_type::receive_closed_signature,
+          R(),
+          typename traits_type::receive_cancelled_signature
+        >::value,
+        channel_payload<
+          R(),
+          typename traits_type::receive_cancelled_signature
+        >,
+        channel_payload<
+          R(),
+          typename traits_type::receive_cancelled_signature,
+          typename traits_type::receive_closed_signature
+        >
+      >::type
+    >::type payload_type;
+
+  // Construct with empty buffer.
+  implementation_type()
+    : buffer_(0)
+  {
+  }
+
+  // Move from another buffer.
+  void buffer_move_from(implementation_type& other)
+  {
+    buffer_ = other.buffer_;
+    other.buffer_ = 0;
+  }
+
+  // Get number of buffered elements.
+  std::size_t buffer_size() const
+  {
+    return buffer_;
+  }
+
+  // Push a new value to the back of the buffer.
+  void buffer_push(payload_type)
+  {
+    ++buffer_;
+  }
+
+  // Push new values to the back of the buffer.
+  std::size_t buffer_push_n(std::size_t count, payload_type)
+  {
+    std::size_t available = this->max_buffer_size_ - buffer_;
+    count = (count < available) ? count : available;
+    buffer_ += count;
+    return count;
+  }
+
+  // Get the element at the front of the buffer.
+  payload_type buffer_front()
+  {
+    return payload_type(channel_message<R()>(0));
+  }
+
+  // Pop a value from the front of the buffer.
+  void buffer_pop()
+  {
+    --buffer_;
+  }
+
+  // Clear all values from the buffer.
+  void buffer_clear()
+  {
+    buffer_ = 0;
+  }
+
+private:
+  // Number of buffered "values".
+  std::size_t buffer_;
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/experimental/detail/impl/channel_service.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SERVICE_HPP
diff --git a/boost/asio/experimental/detail/completion_handler_erasure.hpp b/boost/asio/experimental/detail/completion_handler_erasure.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c3e03f3d87c23db1dbafa259e6d1380d044de10f
--- /dev/null
+++ b/boost/asio/experimental/detail/completion_handler_erasure.hpp
@@ -0,0 +1,196 @@
+//
+// experimental/detail/completion_handler_erasure.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_COMPLETION_HANDLER_ERASURE_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_COMPLETION_HANDLER_ERASURE_HPP
+
+#include <new>
+#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/dispatch.hpp>
+
+namespace boost {
+namespace asio {
+
+class any_io_executor;
+
+namespace experimental {
+namespace detail {
+
+template<typename Signature, typename Executor>
+struct completion_handler_erasure_base;
+
+template<typename Func, typename Signature, typename Executor>
+struct completion_handler_erasure_impl;
+
+template<typename Return, typename... Args, typename Executor>
+struct completion_handler_erasure_base<Return(Args...), Executor>
+{
+  Executor executor;
+
+  completion_handler_erasure_base(Executor&& executor)
+    : executor(std::move(executor))
+  {
+  }
+
+  virtual Return call(Args... args) = 0;
+  virtual void destroy() = 0;
+  virtual ~completion_handler_erasure_base() = default;
+};
+
+template<typename Func, typename Return, typename... Args, typename Executor>
+struct completion_handler_erasure_impl<Func, Return(Args...), Executor> final
+    : completion_handler_erasure_base<Return(Args...), Executor>
+{
+  using allocator_base = typename associated_allocator<Func>::type;
+  using allocator_type =
+    typename std::allocator_traits<allocator_base>::template rebind_alloc<
+      completion_handler_erasure_impl>;
+
+  completion_handler_erasure_impl(Executor&& exec, Func&& func)
+    : completion_handler_erasure_base<Return(Args...), Executor>(
+        std::move(exec)), func(std::move(func))
+  {
+  }
+
+  struct uninit_deleter_t
+  {
+    allocator_type allocator;
+
+    uninit_deleter_t(const Func& func)
+      : allocator(get_associated_allocator(func))
+    {
+    }
+
+    void operator()(completion_handler_erasure_impl* p)
+    {
+      std::allocator_traits<allocator_type>::deallocate(allocator, p, 1);
+    }
+  };
+
+  static completion_handler_erasure_impl* make(Executor exec, Func&& func)
+  {
+    uninit_deleter_t deleter(func);
+    std::unique_ptr<completion_handler_erasure_impl, uninit_deleter_t>
+      uninit_ptr(std::allocator_traits<allocator_type>::allocate(
+            deleter.allocator, 1), deleter);
+    completion_handler_erasure_impl* ptr =
+      new (uninit_ptr.get()) completion_handler_erasure_impl(
+        std::move(exec), std::move(func));
+    uninit_ptr.release();
+    return ptr;
+  }
+
+  struct deleter_t
+  {
+    allocator_type allocator;
+
+    deleter_t(const Func& func)
+      : allocator(get_associated_allocator(func))
+    {
+    }
+
+    void operator()(completion_handler_erasure_impl* p)
+    {
+      std::allocator_traits<allocator_type>::destroy(allocator, p);
+      std::allocator_traits<allocator_type>::deallocate(allocator, p, 1);
+    }
+  };
+
+  virtual Return call(Args... args) override
+  {
+    std::unique_ptr<completion_handler_erasure_impl,
+      deleter_t> p(this, deleter_t(func));
+    Func f(std::move(func));
+    p.reset();
+    std::move(f)(std::move(args)...);
+  }
+
+  virtual void destroy() override
+  {
+    std::unique_ptr<completion_handler_erasure_impl,
+      deleter_t>(this, deleter_t(func));
+  }
+
+  Func func;
+};
+
+template<typename Signature, typename Executor = any_io_executor>
+struct completion_handler_erasure;
+
+template<typename Return, typename... Args, typename Executor>
+struct completion_handler_erasure<Return(Args...), Executor>
+{
+  struct deleter_t
+  {
+    void operator()(
+        completion_handler_erasure_base<Return(Args...), Executor>* p)
+    {
+      p->destroy();
+    }
+  };
+
+  completion_handler_erasure(const completion_handler_erasure&) = delete;
+  completion_handler_erasure(completion_handler_erasure&&) = default;
+  completion_handler_erasure& operator=(
+      const completion_handler_erasure&) = delete;
+  completion_handler_erasure& operator=(
+      completion_handler_erasure&&) = default;
+
+  constexpr completion_handler_erasure() = default;
+
+  constexpr completion_handler_erasure(nullptr_t)
+    : completion_handler_erasure()
+  {
+  }
+
+  template<typename Func>
+  completion_handler_erasure(Executor exec, Func&& func)
+    : impl_(completion_handler_erasure_impl<
+        std::decay_t<Func>, Return(Args...), Executor>::make(
+          std::move(exec), std::forward<Func>(func)))
+  {
+  }
+
+  ~completion_handler_erasure()
+  {
+    if (impl_)
+    {
+      Executor executor(impl_->executor);
+      boost::asio::dispatch(executor,
+          [impl = std::move(impl_)]() mutable
+          {
+            impl.reset();
+          });
+    }
+  }
+
+  Return operator()(Args... args)
+  {
+    if (impl_)
+      impl_.release()->call(std::move(args)...);
+  }
+
+  constexpr bool operator==(nullptr_t) const noexcept {return impl_ == nullptr;}
+  constexpr bool operator!=(nullptr_t) const noexcept {return impl_ != nullptr;}
+  constexpr bool operator!() const noexcept {return impl_ == nullptr;}
+
+private:
+  std::unique_ptr<
+    completion_handler_erasure_base<Return(Args...), Executor>, deleter_t>
+      impl_;
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_COMPLETION_HANDLER_ERASURE_HPP
diff --git a/boost/asio/experimental/detail/coro_promise_allocator.hpp b/boost/asio/experimental/detail/coro_promise_allocator.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..6c7699ebf9325b5e3ea223afdf8ada1ffa902a29
--- /dev/null
+++ b/boost/asio/experimental/detail/coro_promise_allocator.hpp
@@ -0,0 +1,120 @@
+//
+// experimental/detail/coro_promise_allocator.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_CORO_PROMISE_ALLOCATOR_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_CORO_PROMISE_ALLOCATOR_HPP
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/experimental/coro_traits.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename Coroutine,
+     typename Executor = typename Coroutine::executor_type,
+     typename Allocator = typename std::allocator_traits<
+       associated_allocator_t<Executor>>:: template rebind_alloc<std::byte>,
+     bool Noexcept = noexcept(std::declval<Allocator>().allocate(0u))>
+struct coro_promise_allocator
+{
+  using allocator_type = Allocator;
+
+  template <typename... Args>
+  void* operator new(const std::size_t size, Executor executor, Args&&...)
+  {
+    static_assert(std::is_nothrow_move_constructible_v<allocator_type>);
+    allocator_type alloc{get_associated_allocator(executor)};
+
+    const auto csize = size + sizeof(alloc);
+    const auto raw =
+      std::allocator_traits<allocator_type>::allocate(alloc, csize);
+    new (raw) allocator_type(std::move(alloc));
+    return static_cast<std::byte*>(raw) + sizeof(alloc);
+  }
+
+  template <execution_context Context, typename... Args>
+  void* operator new(const std::size_t size, Context&& ctx, Args&&... args)
+  {
+    return coro_promise_allocator::operator new(size,
+        ctx.get_executor(), std::forward<Args>(args)...);
+  }
+
+  void operator delete(void* raw, std::size_t size )
+  {
+    auto * alloc_p = static_cast<allocator_type*>(raw);
+
+    auto alloc = std::move(*alloc_p);
+    alloc_p->~allocator_type();
+    std::allocator_traits<allocator_type>::deallocate(alloc,
+        static_cast<std::byte*>(raw), size + sizeof(allocator_type));
+  }
+};
+
+template <typename Coroutine, typename Executor>
+struct coro_promise_allocator<Coroutine,
+    Executor, std::allocator<std::byte>, false>
+{
+
+};
+
+template <typename Coroutine, typename Executor, typename Allocator>
+struct coro_promise_allocator<Coroutine, Executor, Allocator, true>
+{
+  using allocator_type = Allocator;
+
+  template <typename... Args>
+  void* operator new(const std::size_t size,
+      Executor executor, Args&&...) noexcept
+  {
+    static_assert(std::is_nothrow_move_constructible_v<allocator_type>);
+    allocator_type alloc{get_associated_allocator(executor)};
+
+    const auto csize = size + sizeof(alloc);
+    const auto raw =
+      std::allocator_traits<allocator_type>::allocate(alloc, csize);
+    if (raw == nullptr)
+      return nullptr;
+    new (raw) allocator_type(std::move(alloc));
+    return static_cast<std::byte*>(raw) + sizeof(alloc);
+  }
+
+  template <execution_context Context, typename... Args>
+  void* operator new(const std::size_t size,
+      Context&& ctx, Args&&... args) noexcept
+  {
+    return coro_promise_allocator::operator new(size,
+        ctx.get_executor(), std::forward<Args>(args)...);
+  }
+
+  void operator delete(void* raw, std::size_t size) noexcept
+  {
+    auto * alloc_p = static_cast<allocator_type*>(raw);
+    auto alloc = std::move(*alloc_p);
+    alloc_p->~allocator_type();
+    const auto csize = size + sizeof(allocator_type);
+    std::allocator_traits<allocator_type>::deallocate(alloc,
+        static_cast<std::byte*>(raw) - sizeof(allocator_type), csize);
+  }
+
+  static auto get_return_object_on_allocation_failure() noexcept -> Coroutine
+  {
+    return Coroutine{};
+  }
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_CORO_PROMISE_ALLOCATOR_HPP
diff --git a/boost/asio/experimental/detail/has_signature.hpp b/boost/asio/experimental/detail/has_signature.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ffd330ca399f24c4fb05685805944288afd9eb95
--- /dev/null
+++ b/boost/asio/experimental/detail/has_signature.hpp
@@ -0,0 +1,56 @@
+//
+// experimental/detail/has_signature.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_HAS_SIGNATURE_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_HAS_SIGNATURE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename S, typename... Signatures>
+struct has_signature;
+
+template <typename S, typename... Signatures>
+struct has_signature;
+
+template <typename S>
+struct has_signature<S> : false_type
+{
+};
+
+template <typename S, typename... Signatures>
+struct has_signature<S, S, Signatures...> : true_type
+{
+};
+
+template <typename S, typename Head, typename... Tail>
+struct has_signature<S, Head, Tail...> : has_signature<S, Tail...>
+{
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_HAS_SIGNATURE_HPP
diff --git a/boost/asio/experimental/detail/impl/channel_service.hpp b/boost/asio/experimental/detail/impl/channel_service.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..29c698d364f2ce88b7adeaa1a3a3708c943b29d4
--- /dev/null
+++ b/boost/asio/experimental/detail/impl/channel_service.hpp
@@ -0,0 +1,613 @@
+//
+// experimental/detail/impl/channel_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_IMPL_CHANNEL_SERVICE_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_IMPL_CHANNEL_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename Mutex>
+inline channel_service<Mutex>::channel_service(execution_context& ctx)
+  : boost::asio::detail::execution_context_service_base<channel_service>(ctx),
+    mutex_(),
+    impl_list_(0)
+{
+}
+
+template <typename Mutex>
+inline void channel_service<Mutex>::shutdown()
+{
+  // Abandon all pending operations.
+  boost::asio::detail::op_queue<channel_operation> ops;
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  base_implementation_type* impl = impl_list_;
+  while (impl)
+  {
+    ops.push(impl->waiters_);
+    impl = impl->next_;
+  }
+}
+
+template <typename Mutex>
+inline void channel_service<Mutex>::construct(
+    channel_service<Mutex>::base_implementation_type& impl,
+    std::size_t max_buffer_size)
+{
+  impl.max_buffer_size_ = max_buffer_size;
+  impl.receive_state_ = block;
+  impl.send_state_ = max_buffer_size ? buffer : block;
+
+  // Insert implementation into linked list of all implementations.
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  impl.next_ = impl_list_;
+  impl.prev_ = 0;
+  if (impl_list_)
+    impl_list_->prev_ = &impl;
+  impl_list_ = &impl;
+}
+
+template <typename Mutex>
+template <typename Traits, typename... Signatures>
+void channel_service<Mutex>::destroy(
+    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl)
+{
+  cancel(impl);
+  base_destroy(impl);
+}
+
+template <typename Mutex>
+template <typename Traits, typename... Signatures>
+void channel_service<Mutex>::move_construct(
+    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
+    channel_service<Mutex>::implementation_type<
+      Traits, Signatures...>& other_impl)
+{
+  impl.max_buffer_size_ = other_impl.max_buffer_size_;
+  impl.receive_state_ = other_impl.receive_state_;
+  other_impl.receive_state_ = block;
+  impl.send_state_ = other_impl.send_state_;
+  other_impl.send_state_ = other_impl.max_buffer_size_ ? buffer : block;
+  impl.buffer_move_from(other_impl);
+
+  // Insert implementation into linked list of all implementations.
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  impl.next_ = impl_list_;
+  impl.prev_ = 0;
+  if (impl_list_)
+    impl_list_->prev_ = &impl;
+  impl_list_ = &impl;
+}
+
+template <typename Mutex>
+template <typename Traits, typename... Signatures>
+void channel_service<Mutex>::move_assign(
+    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
+    channel_service& other_service,
+    channel_service<Mutex>::implementation_type<
+      Traits, Signatures...>& other_impl)
+{
+  cancel(impl);
+
+  if (this != &other_service)
+  {
+    // Remove implementation from linked list of all implementations.
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (impl_list_ == &impl)
+      impl_list_ = impl.next_;
+    if (impl.prev_)
+      impl.prev_->next_ = impl.next_;
+    if (impl.next_)
+      impl.next_->prev_= impl.prev_;
+    impl.next_ = 0;
+    impl.prev_ = 0;
+  }
+
+  impl.max_buffer_size_ = other_impl.max_buffer_size_;
+  impl.receive_state_ = other_impl.receive_state_;
+  other_impl.receive_state_ = block;
+  impl.send_state_ = other_impl.send_state_;
+  other_impl.send_state_ = other_impl.max_buffer_size_ ? buffer : block;
+  impl.buffer_move_from(other_impl);
+
+  if (this != &other_service)
+  {
+    // Insert implementation into linked list of all implementations.
+    boost::asio::detail::mutex::scoped_lock lock(other_service.mutex_);
+    impl.next_ = other_service.impl_list_;
+    impl.prev_ = 0;
+    if (other_service.impl_list_)
+      other_service.impl_list_->prev_ = &impl;
+    other_service.impl_list_ = &impl;
+  }
+}
+
+template <typename Mutex>
+inline void channel_service<Mutex>::base_destroy(
+    channel_service<Mutex>::base_implementation_type& impl)
+{
+  // Remove implementation from linked list of all implementations.
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  if (impl_list_ == &impl)
+    impl_list_ = impl.next_;
+  if (impl.prev_)
+    impl.prev_->next_ = impl.next_;
+  if (impl.next_)
+    impl.next_->prev_= impl.prev_;
+  impl.next_ = 0;
+  impl.prev_ = 0;
+}
+
+template <typename Mutex>
+inline std::size_t channel_service<Mutex>::capacity(
+    const channel_service<Mutex>::base_implementation_type& impl)
+  const BOOST_ASIO_NOEXCEPT
+{
+  typename Mutex::scoped_lock lock(impl.mutex_);
+
+  return impl.max_buffer_size_;
+}
+
+template <typename Mutex>
+inline bool channel_service<Mutex>::is_open(
+    const channel_service<Mutex>::base_implementation_type& impl)
+  const BOOST_ASIO_NOEXCEPT
+{
+  typename Mutex::scoped_lock lock(impl.mutex_);
+
+  return impl.send_state_ != closed;
+}
+
+template <typename Mutex>
+template <typename Traits, typename... Signatures>
+void channel_service<Mutex>::reset(
+    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl)
+{
+  cancel(impl);
+
+  typename Mutex::scoped_lock lock(impl.mutex_);
+
+  if (impl.receive_state_ == closed)
+    impl.receive_state_ = block;
+  if (impl.send_state_ == closed)
+    impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
+  impl.buffer_clear();
+}
+
+template <typename Mutex>
+template <typename Traits, typename... Signatures>
+void channel_service<Mutex>::close(
+    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl)
+{
+  typedef typename implementation_type<Traits,
+      Signatures...>::traits_type traits_type;
+  typedef typename implementation_type<Traits,
+      Signatures...>::payload_type payload_type;
+
+  typename Mutex::scoped_lock lock(impl.mutex_);
+
+  if (impl.receive_state_ == block)
+  {
+    while (channel_operation* op = impl.waiters_.front())
+    {
+      impl.waiters_.pop();
+      traits_type::invoke_receive_closed(
+          complete_receive<payload_type,
+            typename traits_type::receive_closed_signature>(
+              static_cast<channel_receive<payload_type>*>(op)));
+    }
+  }
+
+  impl.send_state_ = closed;
+  impl.receive_state_ = closed;
+}
+
+template <typename Mutex>
+template <typename Traits, typename... Signatures>
+void channel_service<Mutex>::cancel(
+    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl)
+{
+  typedef typename implementation_type<Traits,
+      Signatures...>::traits_type traits_type;
+  typedef typename implementation_type<Traits,
+      Signatures...>::payload_type payload_type;
+
+  typename Mutex::scoped_lock lock(impl.mutex_);
+
+  while (channel_operation* op = impl.waiters_.front())
+  {
+    if (impl.send_state_ == block)
+    {
+      impl.waiters_.pop();
+      static_cast<channel_send<payload_type>*>(op)->cancel();
+    }
+    else
+    {
+      impl.waiters_.pop();
+      traits_type::invoke_receive_cancelled(
+          complete_receive<payload_type,
+            typename traits_type::receive_cancelled_signature>(
+              static_cast<channel_receive<payload_type>*>(op)));
+    }
+  }
+
+  if (impl.receive_state_ == waiter)
+    impl.receive_state_ = block;
+  if (impl.send_state_ == waiter)
+    impl.send_state_ = block;
+}
+
+template <typename Mutex>
+template <typename Traits, typename... Signatures>
+void channel_service<Mutex>::cancel_by_key(
+    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
+    void* cancellation_key)
+{
+  typedef typename implementation_type<Traits,
+      Signatures...>::traits_type traits_type;
+  typedef typename implementation_type<Traits,
+      Signatures...>::payload_type payload_type;
+
+  typename Mutex::scoped_lock lock(impl.mutex_);
+
+  boost::asio::detail::op_queue<channel_operation> other_ops;
+  while (channel_operation* op = impl.waiters_.front())
+  {
+    if (op->cancellation_key_ == cancellation_key)
+    {
+      if (impl.send_state_ == block)
+      {
+        impl.waiters_.pop();
+        static_cast<channel_send<payload_type>*>(op)->cancel();
+      }
+      else
+      {
+        impl.waiters_.pop();
+        traits_type::invoke_receive_cancelled(
+            complete_receive<payload_type,
+              typename traits_type::receive_cancelled_signature>(
+                static_cast<channel_receive<payload_type>*>(op)));
+      }
+    }
+    else
+    {
+      impl.waiters_.pop();
+      other_ops.push(op);
+    }
+  }
+  impl.waiters_.push(other_ops);
+
+  if (impl.waiters_.empty())
+  {
+    if (impl.receive_state_ == waiter)
+      impl.receive_state_ = block;
+    if (impl.send_state_ == waiter)
+      impl.send_state_ = block;
+  }
+}
+
+template <typename Mutex>
+inline bool channel_service<Mutex>::ready(
+    const channel_service<Mutex>::base_implementation_type& impl)
+  const BOOST_ASIO_NOEXCEPT
+{
+  typename Mutex::scoped_lock lock(impl.mutex_);
+
+  return impl.receive_state_ != block;
+}
+
+template <typename Mutex>
+template <typename Message, typename Traits,
+    typename... Signatures, typename... Args>
+bool channel_service<Mutex>::try_send(
+    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
+    BOOST_ASIO_MOVE_ARG(Args)... args)
+{
+  typedef typename implementation_type<Traits,
+      Signatures...>::payload_type payload_type;
+
+  typename Mutex::scoped_lock lock(impl.mutex_);
+
+  switch (impl.send_state_)
+  {
+  case block:
+    {
+      return false;
+    }
+  case buffer:
+    {
+      impl.buffer_push(Message(0, BOOST_ASIO_MOVE_CAST(Args)(args)...));
+      impl.receive_state_ = buffer;
+      if (impl.buffer_size() == impl.max_buffer_size_)
+        impl.send_state_ = block;
+      return true;
+    }
+  case waiter:
+    {
+      payload_type payload(Message(0, BOOST_ASIO_MOVE_CAST(Args)(args)...));
+      channel_receive<payload_type>* receive_op =
+        static_cast<channel_receive<payload_type>*>(impl.waiters_.front());
+      impl.waiters_.pop();
+      receive_op->complete(BOOST_ASIO_MOVE_CAST(payload_type)(payload));
+      if (impl.waiters_.empty())
+        impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
+      return true;
+    }
+  case closed:
+  default:
+    {
+      return false;
+    }
+  }
+}
+
+template <typename Mutex>
+template <typename Message, typename Traits,
+    typename... Signatures, typename... Args>
+std::size_t channel_service<Mutex>::try_send_n(
+    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
+		std::size_t count, BOOST_ASIO_MOVE_ARG(Args)... args)
+{
+  typedef typename implementation_type<Traits,
+      Signatures...>::payload_type payload_type;
+
+  typename Mutex::scoped_lock lock(impl.mutex_);
+
+  if (count == 0)
+    return 0;
+
+  switch (impl.send_state_)
+  {
+  case block:
+    return 0;
+  case buffer:
+  case waiter:
+    break;
+  case closed:
+  default:
+    return 0;
+  }
+
+  payload_type payload(Message(0, BOOST_ASIO_MOVE_CAST(Args)(args)...));
+
+  for (std::size_t i = 0; i < count; ++i)
+  {
+    switch (impl.send_state_)
+    {
+    case block:
+      {
+        return i;
+      }
+    case buffer:
+      {
+        i += impl.buffer_push_n(count - i,
+            BOOST_ASIO_MOVE_CAST(payload_type)(payload));
+        impl.receive_state_ = buffer;
+        if (impl.buffer_size() == impl.max_buffer_size_)
+          impl.send_state_ = block;
+        return i;
+      }
+    case waiter:
+      {
+        channel_receive<payload_type>* receive_op =
+          static_cast<channel_receive<payload_type>*>(impl.waiters_.front());
+        impl.waiters_.pop();
+        receive_op->complete(payload);
+        if (impl.waiters_.empty())
+          impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
+        break;
+      }
+    case closed:
+    default:
+      {
+        return i;
+      }
+    }
+  }
+
+  return count;
+}
+
+template <typename Mutex>
+template <typename Traits, typename... Signatures>
+void channel_service<Mutex>::start_send_op(
+    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
+		channel_send<typename implementation_type<
+			Traits, Signatures...>::payload_type>* send_op)
+{
+  typedef typename implementation_type<Traits,
+      Signatures...>::payload_type payload_type;
+
+  typename Mutex::scoped_lock lock(impl.mutex_);
+
+  switch (impl.send_state_)
+  {
+  case block:
+    {
+      impl.waiters_.push(send_op);
+      if (impl.receive_state_ == block)
+        impl.receive_state_ = waiter;
+      return;
+    }
+  case buffer:
+    {
+      impl.buffer_push(send_op->get_payload());
+      impl.receive_state_ = buffer;
+      if (impl.buffer_size() == impl.max_buffer_size_)
+        impl.send_state_ = block;
+      send_op->complete();
+      break;
+    }
+  case waiter:
+    {
+      channel_receive<payload_type>* receive_op =
+        static_cast<channel_receive<payload_type>*>(impl.waiters_.front());
+      impl.waiters_.pop();
+      receive_op->complete(send_op->get_payload());
+      if (impl.waiters_.empty())
+        impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
+      send_op->complete();
+      break;
+    }
+  case closed:
+  default:
+    {
+      send_op->close();
+      break;
+    }
+  }
+}
+
+template <typename Mutex>
+template <typename Traits, typename... Signatures, typename Handler>
+bool channel_service<Mutex>::try_receive(
+    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
+		BOOST_ASIO_MOVE_ARG(Handler) handler)
+{
+  typedef typename implementation_type<Traits,
+      Signatures...>::payload_type payload_type;
+
+  typename Mutex::scoped_lock lock(impl.mutex_);
+
+  switch (impl.receive_state_)
+  {
+  case block:
+    {
+      return false;
+    }
+  case buffer:
+    {
+      payload_type payload(impl.buffer_front());
+      if (channel_send<payload_type>* send_op =
+          static_cast<channel_send<payload_type>*>(impl.waiters_.front()))
+      {
+        impl.buffer_pop();
+        impl.buffer_push(send_op->get_payload());
+        impl.waiters_.pop();
+        send_op->complete();
+      }
+      else
+      {
+        impl.buffer_pop();
+        if (impl.buffer_size() == 0)
+          impl.receive_state_ = (impl.send_state_ == closed) ? closed : block;
+        impl.send_state_ = (impl.send_state_ == closed) ? closed : buffer;
+      }
+      lock.unlock();
+      boost::asio::detail::non_const_lvalue<Handler> handler2(handler);
+      channel_handler<payload_type, typename decay<Handler>::type>(
+          BOOST_ASIO_MOVE_CAST(payload_type)(payload), handler2.value)();
+      return true;
+    }
+  case waiter:
+    {
+      channel_send<payload_type>* send_op =
+        static_cast<channel_send<payload_type>*>(impl.waiters_.front());
+      payload_type payload = send_op->get_payload();
+      impl.waiters_.pop();
+      send_op->complete();
+      if (impl.waiters_.front() == 0)
+        impl.receive_state_ = (impl.send_state_ == closed) ? closed : block;
+      lock.unlock();
+      boost::asio::detail::non_const_lvalue<Handler> handler2(handler);
+      channel_handler<payload_type, typename decay<Handler>::type>(
+          BOOST_ASIO_MOVE_CAST(payload_type)(payload), handler2.value)();
+      return true;
+    }
+  case closed:
+  default:
+    {
+      return false;
+    }
+  }
+}
+
+template <typename Mutex>
+template <typename Traits, typename... Signatures>
+void channel_service<Mutex>::start_receive_op(
+    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
+		channel_receive<typename implementation_type<
+			Traits, Signatures...>::payload_type>* receive_op)
+{
+  typedef typename implementation_type<Traits,
+      Signatures...>::traits_type traits_type;
+  typedef typename implementation_type<Traits,
+      Signatures...>::payload_type payload_type;
+
+  typename Mutex::scoped_lock lock(impl.mutex_);
+
+  switch (impl.receive_state_)
+  {
+  case block:
+    {
+      impl.waiters_.push(receive_op);
+      if (impl.send_state_ != closed)
+        impl.send_state_ = waiter;
+      return;
+    }
+  case buffer:
+    {
+      receive_op->complete(impl.buffer_front());
+      if (channel_send<payload_type>* send_op =
+          static_cast<channel_send<payload_type>*>(impl.waiters_.front()))
+      {
+        impl.buffer_pop();
+        impl.buffer_push(send_op->get_payload());
+        impl.waiters_.pop();
+        send_op->complete();
+      }
+      else
+      {
+        impl.buffer_pop();
+        if (impl.buffer_size() == 0)
+          impl.receive_state_ = (impl.send_state_ == closed) ? closed : block;
+        impl.send_state_ = (impl.send_state_ == closed) ? closed : buffer;
+      }
+      break;
+    }
+  case waiter:
+    {
+      channel_send<payload_type>* send_op =
+        static_cast<channel_send<payload_type>*>(impl.waiters_.front());
+      payload_type payload = send_op->get_payload();
+      impl.waiters_.pop();
+      send_op->complete();
+      receive_op->complete(BOOST_ASIO_MOVE_CAST(payload_type)(payload));
+      if (impl.waiters_.front() == 0)
+        impl.receive_state_ = (impl.send_state_ == closed) ? closed : block;
+      break;
+    }
+  case closed:
+  default:
+    {
+      traits_type::invoke_receive_closed(
+          complete_receive<payload_type,
+            typename traits_type::receive_closed_signature>(receive_op));
+      break;
+    }
+  }
+}
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_IMPL_CHANNEL_SERVICE_HPP
diff --git a/boost/asio/experimental/detail/partial_promise.hpp b/boost/asio/experimental/detail/partial_promise.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c782b8f13e66e3a1c05e99e2e0e7f581ef8c87e5
--- /dev/null
+++ b/boost/asio/experimental/detail/partial_promise.hpp
@@ -0,0 +1,180 @@
+//
+// experimental/detail/partial_promise.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_PARTIAL_PROMISE_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_PARTIAL_PROMISE_HPP
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/awaitable.hpp>
+#include <boost/asio/experimental/coro_traits.hpp>
+
+#if defined(BOOST_ASIO_HAS_STD_COROUTINE)
+# include <coroutine>
+#else // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+# include <experimental/coroutine>
+#endif // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+#if defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+using std::coroutine_handle;
+using std::coroutine_traits;
+using std::suspend_never;
+using std::suspend_always;
+using std::noop_coroutine;
+
+#else // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+using std::experimental::coroutine_handle;
+using std::experimental::coroutine_traits;
+using std::experimental::suspend_never;
+using std::experimental::suspend_always;
+using std::experimental::noop_coroutine;
+
+#endif // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+struct partial_promise
+{
+  auto initial_suspend() noexcept
+  {
+    return boost::asio::detail::suspend_always{};
+  }
+
+  auto final_suspend() noexcept
+  {
+    struct awaitable_t
+    {
+      partial_promise *p;
+
+      constexpr bool await_ready() noexcept { return true; }
+
+      auto await_suspend(boost::asio::detail::coroutine_handle<>) noexcept
+      {
+        p->get_return_object().destroy();
+      }
+
+      constexpr void await_resume() noexcept {}
+    };
+
+    return awaitable_t{this};
+  }
+
+  void return_void() {}
+
+  coroutine_handle<partial_promise> get_return_object()
+  {
+    return coroutine_handle<partial_promise>::from_promise(*this);
+  }
+
+  void unhandled_exception()
+  {
+    assert(false);
+  }
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#if defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+namespace std {
+
+template <typename ... Args>
+struct coroutine_traits<
+    coroutine_handle<boost::asio::experimental::detail::partial_promise>,
+    Args...>
+{
+  using promise_type = boost::asio::experimental::detail::partial_promise;
+};
+
+} // namespace std
+
+#else // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+namespace std { namespace experimental {
+
+template <typename... Args>
+struct coroutine_traits<
+    coroutine_handle<boost::asio::experimental::detail::partial_promise>,
+    Args...>
+{
+  using promise_type = boost::asio::experimental::detail::partial_promise;
+};
+
+}} // namespace std::experimental
+
+#endif // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename CompletionToken>
+auto post_coroutine(CompletionToken token) noexcept
+  -> coroutine_handle<partial_promise>
+{
+  post(std::move(token));
+  co_return;
+}
+
+template <execution::executor Executor, typename CompletionToken>
+auto post_coroutine(Executor exec, CompletionToken token) noexcept
+  -> coroutine_handle<partial_promise>
+{
+  post(exec, std::move(token));
+  co_return;
+}
+
+template <detail::execution_context Context, typename CompletionToken>
+auto post_coroutine(Context &ctx, CompletionToken token) noexcept
+  -> coroutine_handle<partial_promise>
+{
+  post(ctx, std::move(token));
+  co_return;
+}
+
+template <typename CompletionToken>
+auto dispatch_coroutine(CompletionToken token) noexcept
+  -> coroutine_handle<partial_promise>
+{
+  dispatch(std::move(token));
+  co_return;
+}
+
+template <execution::executor Executor, typename CompletionToken>
+auto dispatch_coroutine(Executor exec, CompletionToken token) noexcept
+  -> coroutine_handle<partial_promise>
+{
+  dispatch(exec, std::move(token));
+  co_return;
+}
+
+template <detail::execution_context Context, typename CompletionToken>
+auto dispatch_coroutine(Context &ctx, CompletionToken token) noexcept
+  -> coroutine_handle<partial_promise>
+{
+  dispatch(ctx, std::move(token));
+  co_return;
+}
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_PARTIAL_PROMISE_HPP
diff --git a/boost/asio/experimental/impl/append.hpp b/boost/asio/experimental/impl/append.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..66e8d5175d985f28eda09d9b184f793fdbb18d17
--- /dev/null
+++ b/boost/asio/experimental/impl/append.hpp
@@ -0,0 +1,219 @@
+//
+// experimental/impl/append.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IMPL_EXPERIMENTAL_APPEND_HPP
+#define BOOST_ASIO_IMPL_EXPERIMENTAL_APPEND_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <boost/asio/associator.hpp>
+#include <boost/asio/async_result.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/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+// Class to adapt a append_t as a completion handler.
+template <typename Handler, typename... Values>
+class append_handler
+{
+public:
+  typedef void result_type;
+
+  template <typename H>
+  append_handler(BOOST_ASIO_MOVE_ARG(H) handler, std::tuple<Values...> values)
+    : handler_(BOOST_ASIO_MOVE_CAST(H)(handler)),
+      values_(BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(values))
+  {
+  }
+
+  template <typename... Args>
+  void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    this->invoke(
+        std::make_index_sequence<sizeof...(Values)>{},
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+  template <std::size_t... I, typename... Args>
+  void invoke(std::index_sequence<I...>, BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        BOOST_ASIO_MOVE_CAST(Args)(args)...,
+        BOOST_ASIO_MOVE_CAST(Values)(std::get<I>(values_))...);
+  }
+
+//private:
+  Handler handler_;
+  std::tuple<Values...> values_;
+};
+
+template <typename Handler>
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
+    append_handler<Handler>* this_handler)
+{
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
+  return boost_asio_handler_alloc_helpers::allocate(
+      size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
+    append_handler<Handler>* this_handler)
+{
+  boost_asio_handler_alloc_helpers::deallocate(
+      pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline bool asio_handler_is_continuation(
+    append_handler<Handler>* this_handler)
+{
+  return boost_asio_handler_cont_helpers::is_continuation(
+        this_handler->handler_);
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
+    append_handler<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
+    append_handler<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Signature, typename... Values>
+struct append_signature;
+
+template <typename R, typename... Args, typename... Values>
+struct append_signature<R(Args...), Values...>
+{
+  typedef R type(typename decay<Args>::type..., Values...);
+};
+
+} // namespace detail
+} // namespace experimental
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename CompletionToken, typename... Values, typename Signature>
+struct async_result<
+    experimental::append_t<CompletionToken, Values...>, Signature>
+  : async_result<CompletionToken,
+      typename experimental::detail::append_signature<
+        Signature, Values...>::type>
+{
+  typedef typename experimental::detail::append_signature<
+      Signature, Values...>::type signature;
+
+  template <typename Initiation>
+  struct init_wrapper
+  {
+    init_wrapper(Initiation init)
+      : initiation_(BOOST_ASIO_MOVE_CAST(Initiation)(init))
+    {
+    }
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        std::tuple<Values...> values,
+        BOOST_ASIO_MOVE_ARG(Args)... args)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          experimental::detail::append_handler<
+            typename decay<Handler>::type, Values...>(
+              BOOST_ASIO_MOVE_CAST(Handler)(handler),
+              BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(values)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+    Initiation initiation_;
+  };
+
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, signature,
+      (async_initiate<CompletionToken, signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<CompletionToken&>(),
+        declval<std::tuple<Values...> >(),
+        declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return async_initiate<CompletionToken, signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.token_,
+        BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(token.values_),
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+};
+
+template <template <typename, typename> class Associator,
+    typename Handler, typename... Values, typename DefaultCandidate>
+struct associator<Associator,
+    experimental::detail::append_handler<Handler, Values...>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const experimental::detail::append_handler<Handler, Values...>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_EXPERIMENTAL_APPEND_HPP
diff --git a/boost/asio/experimental/impl/as_single.hpp b/boost/asio/experimental/impl/as_single.hpp
index 336e9a19c69c9a58b40e47d4700bf05a7a88ed7f..c84b14bc8d0336778babf6af31082fc1f3bb8c16 100644
--- a/boost/asio/experimental/impl/as_single.hpp
+++ b/boost/asio/experimental/impl/as_single.hpp
@@ -2,7 +2,7 @@
 // experimental/impl/as_single.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,8 +19,7 @@
 
 #include <tuple>
 
-#include <boost/asio/associated_executor.hpp>
-#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
@@ -56,19 +55,21 @@ public:
 
   void operator()()
   {
-    handler_();
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)();
   }
 
   template <typename Arg>
   void operator()(BOOST_ASIO_MOVE_ARG(Arg) arg)
   {
-    handler_(BOOST_ASIO_MOVE_CAST(Arg)(arg));
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        BOOST_ASIO_MOVE_CAST(Arg)(arg));
   }
 
   template <typename... Args>
   void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
   {
-    handler_(std::make_tuple(BOOST_ASIO_MOVE_CAST(Args)(args)...));
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        std::make_tuple(BOOST_ASIO_MOVE_CAST(Args)(args)...));
   }
 
 //private:
@@ -206,32 +207,17 @@ struct async_result<experimental::as_single_t<CompletionToken>, Signature>
   }
 };
 
-template <typename Handler, typename Executor>
-struct associated_executor<
-    experimental::detail::as_single_handler<Handler>, Executor>
-  : detail::associated_executor_forwarding_base<Handler, Executor>
+template <template <typename, typename> class Associator,
+    typename Handler, typename DefaultCandidate>
+struct associator<Associator,
+    experimental::detail::as_single_handler<Handler>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_executor<Handler, Executor>::type type;
-
-  static type get(
-      const experimental::detail::as_single_handler<Handler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
-  }
-};
-
-template <typename Handler, typename Allocator>
-struct associated_allocator<
-    experimental::detail::as_single_handler<Handler>, Allocator>
-{
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(
+  static typename Associator<Handler, DefaultCandidate>::type get(
       const experimental::detail::as_single_handler<Handler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
diff --git a/boost/asio/experimental/impl/as_tuple.hpp b/boost/asio/experimental/impl/as_tuple.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..290d9759518c7c3bbf9e90d280de66d9ca6b0822
--- /dev/null
+++ b/boost/asio/experimental/impl/as_tuple.hpp
@@ -0,0 +1,248 @@
+//
+// experimental/impl/as_tuple.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IMPL_EXPERIMENTAL_AS_TUPLE_HPP
+#define BOOST_ASIO_IMPL_EXPERIMENTAL_AS_TUPLE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <tuple>
+
+#include <boost/asio/associator.hpp>
+#include <boost/asio/async_result.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/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+// Class to adapt a as_tuple_t as a completion handler.
+template <typename Handler>
+class as_tuple_handler
+{
+public:
+  typedef void result_type;
+
+  template <typename CompletionToken>
+  as_tuple_handler(as_tuple_t<CompletionToken> e)
+    : handler_(BOOST_ASIO_MOVE_CAST(CompletionToken)(e.token_))
+  {
+  }
+
+  template <typename RedirectedHandler>
+  as_tuple_handler(BOOST_ASIO_MOVE_ARG(RedirectedHandler) h)
+    : handler_(BOOST_ASIO_MOVE_CAST(RedirectedHandler)(h))
+  {
+  }
+
+  template <typename... Args>
+  void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        std::make_tuple(BOOST_ASIO_MOVE_CAST(Args)(args)...));
+  }
+
+//private:
+  Handler handler_;
+};
+
+template <typename Handler>
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
+    as_tuple_handler<Handler>* this_handler)
+{
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
+  return boost_asio_handler_alloc_helpers::allocate(
+      size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
+    as_tuple_handler<Handler>* this_handler)
+{
+  boost_asio_handler_alloc_helpers::deallocate(
+      pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline bool asio_handler_is_continuation(
+    as_tuple_handler<Handler>* this_handler)
+{
+  return boost_asio_handler_cont_helpers::is_continuation(
+        this_handler->handler_);
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
+    as_tuple_handler<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
+    as_tuple_handler<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Signature>
+struct as_tuple_signature;
+
+template <typename R, typename... Args>
+struct as_tuple_signature<R(Args...)>
+{
+  typedef R type(std::tuple<typename decay<Args>::type...>);
+};
+
+#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+template <typename R, typename... Args>
+struct as_tuple_signature<R(Args...) &>
+{
+  typedef R type(std::tuple<typename decay<Args>::type...>) &;
+};
+
+template <typename R, typename... Args>
+struct as_tuple_signature<R(Args...) &&>
+{
+  typedef R type(std::tuple<typename decay<Args>::type...>) &&;
+};
+
+# if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
+template <typename R, typename... Args>
+struct as_tuple_signature<R(Args...) noexcept>
+{
+  typedef R type(std::tuple<typename decay<Args>::type...>) noexcept;
+};
+
+template <typename R, typename... Args>
+struct as_tuple_signature<R(Args...) & noexcept>
+{
+  typedef R type(std::tuple<typename decay<Args>::type...>) & noexcept;
+};
+
+template <typename R, typename... Args>
+struct as_tuple_signature<R(Args...) && noexcept>
+{
+  typedef R type(std::tuple<typename decay<Args>::type...>) && noexcept;
+};
+
+# endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+} // namespace detail
+} // namespace experimental
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename CompletionToken, typename... Signatures>
+struct async_result<experimental::as_tuple_t<CompletionToken>, Signatures...>
+  : async_result<CompletionToken,
+      typename experimental::detail::as_tuple_signature<Signatures>::type...>
+{
+  typedef async_result<CompletionToken,
+    typename experimental::detail::as_tuple_signature<Signatures>::type...>
+      base_async_result;
+
+  template <typename Initiation>
+  struct init_wrapper
+  {
+    init_wrapper(Initiation init)
+      : initiation_(BOOST_ASIO_MOVE_CAST(Initiation)(init))
+    {
+    }
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        BOOST_ASIO_MOVE_ARG(Args)... args)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          experimental::detail::as_tuple_handler<
+            typename decay<Handler>::type>(
+              BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+    Initiation initiation_;
+  };
+
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken,
+      typename experimental::detail::as_tuple_signature<Signatures>::type...,
+      (base_async_result::initiate(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<CompletionToken>(),
+        declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return base_async_result::initiate(
+        init_wrapper<typename decay<Initiation>::type>(
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.token_, BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+};
+
+template <template <typename, typename> class Associator,
+    typename Handler, typename DefaultCandidate>
+struct associator<Associator,
+    experimental::detail::as_tuple_handler<Handler>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const experimental::detail::as_tuple_handler<Handler>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_EXPERIMENTAL_AS_TUPLE_HPP
diff --git a/boost/asio/experimental/impl/channel_error.ipp b/boost/asio/experimental/impl/channel_error.ipp
new file mode 100644
index 0000000000000000000000000000000000000000..e5e762e4c9e61b87f5a617e5098407d72ac23fcc
--- /dev/null
+++ b/boost/asio/experimental/impl/channel_error.ipp
@@ -0,0 +1,63 @@
+//
+// experimental/impl/channel_error.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_IMPL_CHANNEL_ERROR_IPP
+#define BOOST_ASIO_EXPERIMENTAL_IMPL_CHANNEL_ERROR_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/experimental/channel_error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace error {
+namespace detail {
+
+class channel_category : public boost::system::error_category
+{
+public:
+  const char* name() const BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT
+  {
+    return "asio.channel";
+  }
+
+  std::string message(int value) const
+  {
+    switch (value)
+    {
+    case channel_closed: return "Channel closed";
+    case channel_cancelled: return "Channel cancelled";
+    default: return "asio.channel error";
+    }
+  }
+};
+
+} // namespace detail
+
+const boost::system::error_category& get_channel_category()
+{
+  static detail::channel_category instance;
+  return instance;
+}
+
+} // namespace error
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_IMPL_CHANNEL_ERROR_IPP
diff --git a/boost/asio/experimental/impl/coro.hpp b/boost/asio/experimental/impl/coro.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ab875498c2dcc18c29ed64ad8b652258621f6fe3
--- /dev/null
+++ b/boost/asio/experimental/impl/coro.hpp
@@ -0,0 +1,1201 @@
+//
+// experimental/impl/coro.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//
+#ifndef BOOST_ASIO_EXPERIMENTAL_IMPL_CORO_HPP
+#define BOOST_ASIO_EXPERIMENTAL_IMPL_CORO_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+template <typename Yield, typename Return, typename Executor>
+struct coro;
+
+namespace detail {
+
+struct coro_cancellation_source
+{
+  cancellation_slot slot;
+  cancellation_state state;
+  bool throw_if_cancelled_ = true;
+
+  void reset_cancellation_state()
+  {
+    state = cancellation_state(slot);
+  }
+
+  template <typename Filter>
+  void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(Filter) filter)
+  {
+    state = cancellation_state(slot, BOOST_ASIO_MOVE_CAST(Filter)(filter));
+  }
+
+  template <typename InFilter, typename OutFilter>
+  void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
+      BOOST_ASIO_MOVE_ARG(OutFilter) out_filter)
+  {
+    state = cancellation_state(slot,
+        BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
+        BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter));
+  }
+
+  bool throw_if_cancelled() const
+  {
+    return throw_if_cancelled_;
+  }
+
+  void throw_if_cancelled(bool value)
+  {
+    throw_if_cancelled_ = value;
+  }
+};
+
+template <typename Signature, typename Return, typename Executor>
+struct coro_promise;
+
+template <typename T>
+struct is_noexcept : std::false_type
+{
+};
+
+template <typename Return, typename... Args>
+struct is_noexcept<Return(Args...)> : std::false_type
+{
+};
+
+template <typename Return, typename... Args>
+struct is_noexcept<Return(Args...) noexcept> : std::true_type
+{
+};
+
+template <typename T>
+constexpr bool is_noexcept_v = is_noexcept<T>::value;
+
+template <typename T>
+struct coro_error;
+
+template <>
+struct coro_error<boost::system::error_code>
+{
+  static boost::system::error_code invalid()
+  {
+    return boost::asio::error::fault;
+  }
+
+  static boost::system::error_code cancelled()
+  {
+    return boost::asio::error::operation_aborted;
+  }
+
+  static boost::system::error_code interrupted()
+  {
+    return boost::asio::error::interrupted;
+  }
+
+  static boost::system::error_code done()
+  {
+    return boost::asio::error::broken_pipe;
+  }
+};
+
+template <>
+struct coro_error<std::exception_ptr>
+{
+  static std::exception_ptr invalid()
+  {
+    return std::make_exception_ptr(
+        boost::system::system_error(
+          coro_error<boost::system::error_code>::invalid()));
+  }
+
+  static std::exception_ptr cancelled()
+  {
+    return std::make_exception_ptr(
+        boost::system::system_error(
+          coro_error<boost::system::error_code>::cancelled()));
+  }
+
+  static std::exception_ptr interrupted()
+  {
+    return std::make_exception_ptr(
+        boost::system::system_error(
+          coro_error<boost::system::error_code>::interrupted()));
+  }
+
+  static std::exception_ptr done()
+  {
+    return std::make_exception_ptr(
+        boost::system::system_error(
+          coro_error<boost::system::error_code>::done()));
+  }
+};
+
+template <typename T, typename Coroutine >
+struct coro_with_arg
+{
+  using coro_t = Coroutine;
+  T value;
+  coro_t& coro;
+
+  struct awaitable_t
+  {
+    T value;
+    coro_t& coro;
+
+    constexpr static bool await_ready() { return false; }
+
+    template <typename Y, typename R, typename E>
+    auto await_suspend(coroutine_handle<coro_promise<Y, R, E>> h)
+      -> coroutine_handle<>
+    {
+      auto& hp = h.promise();
+
+      if constexpr (!coro_promise<Y, R, E>::is_noexcept)
+      {
+        if ((hp.cancel->state.cancelled() != cancellation_type::none)
+            && hp.cancel->throw_if_cancelled_)
+        {
+          boost::asio::detail::throw_error(
+              boost::asio::error::operation_aborted, "coro-cancelled");
+        }
+      }
+
+      if (hp.get_executor() == coro.get_executor())
+      {
+        coro.coro_->awaited_from = h;
+        coro.coro_->reset_error();
+        coro.coro_->input_ = std::move(value);
+        coro.coro_->cancel = hp.cancel;
+        return coro.coro_->get_handle();
+      }
+      else
+      {
+        coro.coro_->awaited_from =
+          dispatch_coroutine(
+              boost::asio::prefer(hp.get_executor(),
+                execution::outstanding_work.tracked),
+                [h]() mutable { h.resume(); });
+
+        coro.coro_->reset_error();
+        coro.coro_->input_ = std::move(value);
+
+        struct cancel_handler
+        {
+          using src = std::pair<cancellation_signal,
+                detail::coro_cancellation_source>;
+
+          std::shared_ptr<src> st = std::make_shared<src>();
+
+          cancel_handler(E e, coro_t& coro) : e(e), coro_(coro.coro_)
+          {
+            st->second.state =
+              cancellation_state(st->second.slot = st->first.slot());
+          }
+
+          E e;
+          typename coro_t::promise_type* coro_;
+
+          void operator()(cancellation_type ct)
+          {
+            boost::asio::dispatch(e, [ct, st = st]() mutable
+            {
+              auto & [sig, state] = *st;
+              sig.emit(ct);
+            });
+          }
+        };
+
+        if (hp.cancel->state.slot().is_connected())
+        {
+          hp.cancel->state.slot().template emplace<cancel_handler>(
+              coro.get_executor(), coro);
+        }
+
+        auto hh = detail::coroutine_handle<
+          typename coro_t::promise_type>::from_promise(*coro.coro_);
+
+        return dispatch_coroutine(
+            coro.coro_->get_executor(), [hh]() mutable { hh.resume(); });
+      }
+    }
+
+    auto await_resume() -> typename coro_t::result_type
+    {
+      coro.coro_->cancel = nullptr;
+      coro.coro_->rethrow_if();
+      return std::move(coro.coro_->result_);
+    }
+  };
+
+  template <typename CompletionToken>
+  auto async_resume(CompletionToken&& token) &&
+  {
+    return coro.async_resume(std::move(value),
+        std::forward<CompletionToken>(token));
+  }
+
+  auto operator co_await() &&
+  {
+    return awaitable_t{std::move(value), coro};
+  }
+};
+
+template <bool IsNoexcept>
+struct coro_promise_error;
+
+template <>
+struct coro_promise_error<false>
+{
+  std::exception_ptr error_;
+
+  void reset_error()
+  {
+    error_ = std::exception_ptr{};
+  }
+
+  void unhandled_exception()
+  {
+    error_ = std::current_exception();
+  }
+
+  void rethrow_if()
+  {
+    if (error_)
+      std::rethrow_exception(error_);
+  }
+};
+
+#if defined(__GNUC__)
+# pragma GCC diagnostic push
+# if defined(__clang__)
+#  pragma GCC diagnostic ignored "-Wexceptions"
+# else
+#  pragma GCC diagnostic ignored "-Wterminate"
+# endif
+#elif defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning (disable:4297)
+#endif
+
+template <>
+struct coro_promise_error<true>
+{
+  void reset_error()
+  {
+  }
+
+  void unhandled_exception() noexcept
+  {
+    throw;
+  }
+
+  void rethrow_if()
+  {
+  }
+};
+
+#if defined(__GNUC__)
+# pragma GCC diagnostic pop
+#elif defined(_MSC_VER)
+# pragma warning(pop)
+#endif
+
+template <typename T = void>
+struct yield_input
+{
+  T& value;
+  coroutine_handle<> awaited_from{noop_coroutine()};
+
+  bool await_ready() const noexcept
+  {
+    return false;
+  }
+
+  template <typename U>
+  coroutine_handle<> await_suspend(coroutine_handle<U>) noexcept
+  {
+    return std::exchange(awaited_from, noop_coroutine());
+  }
+
+  T await_resume() const noexcept
+  {
+    return std::move(value);
+  }
+};
+
+template <>
+struct yield_input<void>
+{
+  coroutine_handle<> awaited_from{noop_coroutine()};
+
+  bool await_ready() const noexcept
+  {
+    return false;
+  }
+
+  auto await_suspend(coroutine_handle<>) noexcept
+  {
+    return std::exchange(awaited_from, noop_coroutine());
+  }
+
+  constexpr void await_resume() const noexcept
+  {
+  }
+};
+
+struct coro_awaited_from
+{
+  coroutine_handle<> awaited_from{noop_coroutine()};
+
+  auto final_suspend() noexcept
+  {
+    struct suspendor
+    {
+      coroutine_handle<> awaited_from;
+
+      constexpr static bool await_ready() noexcept
+      {
+        return false;
+      }
+
+      auto await_suspend(coroutine_handle<>) noexcept
+      {
+        return std::exchange(awaited_from, noop_coroutine());
+      }
+
+      constexpr static void await_resume() noexcept
+      {
+      }
+    };
+
+    return suspendor{std::exchange(awaited_from, noop_coroutine())};
+  }
+
+  ~coro_awaited_from()
+  {
+    awaited_from.resume();
+  }//must be on the right executor
+};
+
+template <typename Yield, typename Input, typename Return>
+struct coro_promise_exchange : coro_awaited_from
+{
+  using result_type = coro_result_t<Yield, Return>;
+
+  result_type result_;
+  Input input_;
+
+  auto yield_value(Yield&& y)
+  {
+    result_ = std::move(y);
+    return yield_input<Input>{std::move(input_),
+        std::exchange(awaited_from, noop_coroutine())};
+  }
+
+  auto yield_value(const Yield& y)
+  {
+    result_ = y;
+    return yield_input<Input>{std::move(input_),
+        std::exchange(awaited_from, noop_coroutine())};
+  }
+
+  void return_value(const Return& r)
+  {
+    result_ = r;
+  }
+
+  void return_value(Return&& r)
+  {
+    result_ = std::move(r);
+  }
+};
+
+template <typename YieldReturn>
+struct coro_promise_exchange<YieldReturn, void, YieldReturn> : coro_awaited_from
+{
+  using result_type = coro_result_t<YieldReturn, YieldReturn>;
+
+  result_type result_;
+
+  auto yield_value(const YieldReturn& y)
+  {
+    result_ = y;
+    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
+  }
+
+  auto yield_value(YieldReturn&& y)
+  {
+    result_ = std::move(y);
+    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
+  }
+
+  void return_value(const YieldReturn& r)
+  {
+    result_ = r;
+  }
+
+  void return_value(YieldReturn&& r)
+  {
+    result_ = std::move(r);
+  }
+};
+
+template <typename Yield, typename Return>
+struct coro_promise_exchange<Yield, void, Return> : coro_awaited_from
+{
+  using result_type = coro_result_t<Yield, Return>;
+
+  result_type result_;
+
+  auto yield_value(const Yield& y)
+  {
+    result_.template emplace<0>(y);
+    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
+  }
+
+  auto yield_value(Yield&& y)
+  {
+    result_.template emplace<0>(std::move(y));
+    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
+  }
+
+  void return_value(const Return& r)
+  {
+    result_.template emplace<1>(r);
+  }
+
+  void return_value(Return&& r)
+  {
+    result_.template emplace<1>(std::move(r));
+  }
+};
+
+template <typename Yield, typename Input>
+struct coro_promise_exchange<Yield, Input, void> : coro_awaited_from
+{
+  using result_type = coro_result_t<Yield, void>;
+
+  result_type result_;
+  Input input_;
+
+  auto yield_value(Yield&& y)
+  {
+    result_ = std::move(y);
+    return yield_input<Input>{input_,
+                              std::exchange(awaited_from, noop_coroutine())};
+  }
+
+  auto yield_value(const Yield& y)
+  {
+    result_ = y;
+    return yield_input<Input>{input_,
+                              std::exchange(awaited_from, noop_coroutine())};
+  }
+
+  void return_void()
+  {
+    result_.reset();
+  }
+};
+
+template <typename Return>
+struct coro_promise_exchange<void, void, Return> : coro_awaited_from
+{
+  using result_type = coro_result_t<void, Return>;
+
+  result_type result_;
+
+  void yield_value();
+
+  void return_value(const Return& r)
+  {
+    result_ = r;
+  }
+
+  void return_value(Return&& r)
+  {
+    result_ = std::move(r);
+  }
+};
+
+template <>
+struct coro_promise_exchange<void, void, void> : coro_awaited_from
+{
+  void return_void() {}
+
+  void yield_value();
+};
+
+template <typename Yield>
+struct coro_promise_exchange<Yield, void, void> : coro_awaited_from
+{
+  using result_type = coro_result_t<Yield, void>;
+
+  result_type result_;
+
+  auto yield_value(const Yield& y)
+  {
+    result_ = y;
+    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
+  }
+
+  auto yield_value(Yield&& y)
+  {
+    result_ = std::move(y);
+    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
+  }
+
+  void return_void()
+  {
+    result_.reset();
+  }
+};
+
+template <typename Yield, typename Return, typename Executor>
+struct coro_promise final :
+  coro_promise_allocator<coro<Yield, Return, Executor>>,
+  coro_promise_error<coro_traits<Yield, Return, Executor>::is_noexcept>,
+  coro_promise_exchange<
+      typename coro_traits<Yield, Return, Executor>::yield_type,
+      typename coro_traits<Yield, Return, Executor>::input_type,
+      typename coro_traits<Yield, Return, Executor>::return_type>
+{
+  using coro_type = coro<Yield, Return, Executor>;
+
+  auto handle()
+  {
+    return coroutine_handle<coro_promise>::from_promise(this);
+  }
+
+  using executor_type = Executor;
+
+  executor_type executor_;
+
+  std::optional<coro_cancellation_source> cancel_source;
+  coro_cancellation_source * cancel;
+
+  using allocator_type =
+    typename std::allocator_traits<associated_allocator_t<Executor>>::
+      template rebind_alloc<std::byte>;
+  using traits = coro_traits<Yield, Return, Executor>;
+
+  using input_type = typename traits::input_type;
+  using yield_type = typename traits::yield_type;
+  using return_type = typename traits::return_type;
+  using error_type = typename traits::error_type;
+  using result_type = typename traits::result_type;
+  constexpr static bool is_noexcept = traits::is_noexcept;
+
+  auto get_executor() const -> Executor
+  {
+    return executor_;
+  }
+
+  auto get_handle()
+  {
+    return coroutine_handle<coro_promise>::from_promise(*this);
+  }
+
+  template <typename... Args>
+  coro_promise(Executor executor, Args&&...) noexcept
+    : executor_(std::move(executor))
+  {
+  }
+
+  template <typename First, typename... Args>
+  coro_promise(First&&, Executor executor, Args&&...) noexcept
+    : executor_(std::move(executor))
+  {
+  }
+
+  template <typename First, detail::execution_context Context, typename... Args>
+  coro_promise(First&&, Context&& ctx, Args&&...) noexcept
+    : executor_(ctx.get_executor())
+  {
+  }
+
+  template <detail::execution_context Context, typename... Args>
+  coro_promise(Context&& ctx, Args&&...) noexcept
+    : executor_(ctx.get_executor())
+  {
+  }
+
+  auto get_return_object()
+  {
+    return coro<Yield, Return, Executor>{this};
+  }
+
+  auto initial_suspend() noexcept
+  {
+    return suspend_always{};
+  }
+
+  using coro_promise_exchange<
+      typename coro_traits<Yield, Return, Executor>::yield_type,
+      typename coro_traits<Yield, Return, Executor>::input_type,
+      typename coro_traits<Yield, Return, Executor>::return_type>::yield_value;
+
+  auto await_transform(this_coro::executor_t) const
+  {
+    struct exec_helper
+    {
+      const executor_type& value;
+
+      constexpr static bool await_ready() noexcept
+      {
+        return true;
+      }
+
+      constexpr static void await_suspend(coroutine_handle<>) noexcept
+      {
+      }
+
+      executor_type await_resume() const noexcept
+      {
+        return value;
+      }
+    };
+
+    return exec_helper{executor_};
+  }
+
+  auto await_transform(this_coro::cancellation_state_t) const
+  {
+    struct exec_helper
+    {
+      const boost::asio::cancellation_state& value;
+
+      constexpr static bool await_ready() noexcept
+      {
+        return true;
+      }
+
+      constexpr static void await_suspend(coroutine_handle<>) noexcept
+      {
+      }
+
+      boost::asio::cancellation_state await_resume() const noexcept
+      {
+        return value;
+      }
+    };
+    assert(cancel);
+    return exec_helper{cancel->state};
+  }
+
+  // This await transformation resets the associated cancellation state.
+  auto await_transform(this_coro::reset_cancellation_state_0_t) noexcept
+  {
+    struct result
+    {
+      detail::coro_cancellation_source * src_;
+
+      bool await_ready() const noexcept
+      {
+        return true;
+      }
+
+      void await_suspend(coroutine_handle<void>) noexcept
+      {
+      }
+
+      auto await_resume() const
+      {
+        return src_->reset_cancellation_state();
+      }
+    };
+
+    return result{cancel};
+  }
+
+  // This await transformation resets the associated cancellation state.
+  template <typename Filter>
+  auto await_transform(
+      this_coro::reset_cancellation_state_1_t<Filter> reset) noexcept
+  {
+    struct result
+    {
+      detail::coro_cancellation_source* src_;
+      Filter filter_;
+
+      bool await_ready() const noexcept
+      {
+        return true;
+      }
+
+      void await_suspend(coroutine_handle<void>) noexcept
+      {
+      }
+
+      auto await_resume()
+      {
+        return src_->reset_cancellation_state(
+            BOOST_ASIO_MOVE_CAST(Filter)(filter_));
+      }
+    };
+
+    return result{cancel, BOOST_ASIO_MOVE_CAST(Filter)(reset.filter)};
+  }
+
+  // This await transformation resets the associated cancellation state.
+  template <typename InFilter, typename OutFilter>
+  auto await_transform(
+      this_coro::reset_cancellation_state_2_t<InFilter, OutFilter> reset)
+  noexcept
+  {
+    struct result
+    {
+      detail::coro_cancellation_source* src_;
+      InFilter in_filter_;
+      OutFilter out_filter_;
+
+      bool await_ready() const noexcept
+      {
+        return true;
+      }
+
+      void await_suspend(coroutine_handle<void>) noexcept
+      {
+      }
+
+      auto await_resume()
+      {
+        return src_->reset_cancellation_state(
+            BOOST_ASIO_MOVE_CAST(InFilter)(in_filter_),
+            BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter_));
+      }
+    };
+
+    return result{cancel,
+        BOOST_ASIO_MOVE_CAST(InFilter)(reset.in_filter),
+        BOOST_ASIO_MOVE_CAST(OutFilter)(reset.out_filter)};
+  }
+
+  // This await transformation determines whether cancellation is propagated as
+  // an exception.
+  auto await_transform(this_coro::throw_if_cancelled_0_t) noexcept
+    requires (!is_noexcept)
+  {
+    struct result
+    {
+      detail::coro_cancellation_source* src_;
+
+      bool await_ready() const noexcept
+      {
+        return true;
+      }
+
+      void await_suspend(coroutine_handle<void>) noexcept
+      {
+      }
+
+      auto await_resume()
+      {
+        return src_->throw_if_cancelled();
+      }
+    };
+
+    return result{cancel};
+  }
+
+  // This await transformation sets whether cancellation is propagated as an
+  // exception.
+  auto await_transform(
+      this_coro::throw_if_cancelled_1_t throw_if_cancelled) noexcept
+    requires (!is_noexcept)
+  {
+    struct result
+    {
+      detail::coro_cancellation_source* src_;
+      bool value_;
+
+      bool await_ready() const noexcept
+      {
+        return true;
+      }
+
+      void await_suspend(coroutine_handle<void>) noexcept
+      {
+      }
+
+      auto await_resume()
+      {
+        src_->throw_if_cancelled(value_);
+      }
+    };
+
+    return result{cancel, throw_if_cancelled.value};
+  }
+
+  template <typename Yield_, typename Return_, typename Executor_>
+  auto await_transform(coro<Yield_, Return_, Executor_>& kr) -> decltype(auto)
+  {
+    return kr;
+  }
+
+  template <typename Yield_, typename Return_, typename Executor_>
+  auto await_transform(coro<Yield_, Return_, Executor_>&& kr)
+  {
+    return std::move(kr);
+  }
+
+  template <typename T_, typename Coroutine >
+  auto await_transform(coro_with_arg<T_, Coroutine>&& kr) -> decltype(auto)
+  {
+    return std::move(kr);
+  }
+
+  template <typename T_>
+    requires requires(T_ t) {{ t.async_wait(use_coro) }; }
+  auto await_transform(T_& t) -> decltype(auto)
+  {
+    return await_transform(t.async_wait(use_coro));
+  }
+
+  template <typename... Ts>
+  auto await_transform(coro_init_handler<Executor, Ts...>&& kr) const
+  {
+    assert(cancel);
+    if constexpr (is_noexcept)
+      return std::move(kr).as_noexcept(cancel->state.slot());
+    else
+    {
+      if ((cancel->state.cancelled() != cancellation_type::none)
+          && cancel->throw_if_cancelled_)
+      {
+        boost::asio::detail::throw_error(
+            boost::asio::error::operation_aborted, "coro-cancelled");
+      }
+      return std::move(kr).as_throwing(cancel->state.slot());
+    }
+  }
+};
+
+} // namespace detail
+
+template <typename Yield, typename Return, typename Executor>
+struct coro<Yield, Return, Executor>::awaitable_t
+{
+  coro& coro_;
+
+  constexpr static bool await_ready() { return false; }
+
+  template <typename Y, typename R, typename E>
+  auto await_suspend(
+      detail::coroutine_handle<detail::coro_promise<Y, R, E>> h)
+    -> detail::coroutine_handle<>
+  {
+    auto& hp = h.promise();
+
+    if constexpr (!detail::coro_promise<Y, R, E>::is_noexcept)
+    {
+      if ((hp.cancel->state.cancelled() != cancellation_type::none)
+          && hp.cancel->throw_if_cancelled_)
+      {
+        boost::asio::detail::throw_error(
+            boost::asio::error::operation_aborted, "coro-cancelled");
+      }
+    }
+
+    if (hp.get_executor() == coro_.get_executor())
+    {
+      coro_.coro_->awaited_from  = h;
+      coro_.coro_->cancel = hp.cancel;
+      coro_.coro_->reset_error();
+
+      return coro_.coro_->get_handle();
+    }
+    else
+    {
+      coro_.coro_->awaited_from = detail::dispatch_coroutine(
+          boost::asio::prefer(hp.get_executor(),
+            execution::outstanding_work.tracked),
+          [h]() mutable
+          {
+            h.resume();
+          });
+
+      coro_.coro_->reset_error();
+
+      struct cancel_handler
+      {
+        std::shared_ptr<std::pair<cancellation_signal,
+          detail::coro_cancellation_source>> st = std::make_shared<
+            std::pair<cancellation_signal, detail::coro_cancellation_source>>();
+
+        cancel_handler(E e, coro& coro) : e(e), coro_(coro.coro_)
+        {
+          st->second.state = cancellation_state(
+              st->second.slot = st->first.slot());
+        }
+
+        E e;
+        typename coro::promise_type* coro_;
+
+        void operator()(cancellation_type ct)
+        {
+          boost::asio::dispatch(e,
+              [ct, st = st]() mutable
+              {
+                auto & [sig, state] = *st;
+                sig.emit(ct);
+              });
+        }
+      };
+
+      if (hp.cancel->state.slot().is_connected())
+      {
+        hp.cancel->state.slot().template emplace<cancel_handler>(
+            coro_.get_executor(), coro_);
+      }
+
+      auto hh = detail::coroutine_handle<
+        detail::coro_promise<Yield, Return, Executor>>::from_promise(
+            *coro_.coro_);
+
+      return detail::dispatch_coroutine(
+          coro_.coro_->get_executor(),
+          [hh]() mutable { hh.resume(); });
+    }
+  }
+
+  auto await_resume() -> result_type
+  {
+    coro_.coro_->cancel = nullptr;
+    coro_.coro_->rethrow_if();
+    if constexpr (!std::is_void_v<result_type>)
+      return std::move(coro_.coro_->result_);
+  }
+};
+
+template <typename Yield, typename Return, typename Executor>
+struct coro<Yield, Return, Executor>::initiate_async_resume
+{
+  typedef Executor executor_type;
+
+  explicit initiate_async_resume(coro* self)
+    : coro_(self->coro_)
+  {
+  }
+
+  executor_type get_executor() const noexcept
+  {
+    return coro_->get_executor();
+  }
+
+  template <typename E, typename WaitHandler>
+  auto handle(E exec, WaitHandler&& handler,
+      std::true_type /* error is noexcept */,
+      std::true_type /* result is void */)  //noexcept
+  {
+    return [this, coro = coro_,
+        h = std::forward<WaitHandler>(handler),
+        exec = std::move(exec)]() mutable
+    {
+      assert(coro);
+
+      auto ch = detail::coroutine_handle<promise_type>::from_promise(*coro);
+      assert(ch && !ch.done());
+      assert(coro->awaited_from == detail::noop_coroutine());
+
+      coro->awaited_from = post_coroutine(std::move(exec), std::move(h));
+      coro->reset_error();
+      ch.resume();
+    };
+  }
+
+  template <typename E, typename WaitHandler>
+  requires (!std::is_void_v<result_type>)
+  auto handle(E exec, WaitHandler&& handler,
+      std::true_type /* error is noexcept */,
+      std::false_type  /* result is void */)  //noexcept
+  {
+    return [coro = coro_,
+        h = std::forward<WaitHandler>(handler),
+        exec = std::move(exec)]() mutable
+    {
+      assert(coro);
+
+      auto ch = detail::coroutine_handle<promise_type>::from_promise(*coro);
+      assert(ch && !ch.done());
+      assert(coro->awaited_from == detail::noop_coroutine());
+
+      coro->awaited_from = detail::post_coroutine(exec,
+          [coro, h = std::move(h)]() mutable
+          {
+            std::move(h)(std::move(coro->result_));
+          });
+      coro->reset_error();
+      ch.resume();
+    };
+  }
+
+  template <typename E, typename WaitHandler>
+  auto handle(E exec, WaitHandler&& handler,
+      std::false_type /* error is noexcept */,
+      std::true_type /* result is void */)
+  {
+    return [coro = coro_,
+        h = std::forward<WaitHandler>(handler),
+        exec = std::move(exec)]() mutable
+    {
+      if (!coro)
+      {
+        boost::asio::post(exec,
+            [h = std::move(h)]() mutable
+            {
+              h(detail::coro_error<error_type>::invalid());
+            });
+        return;
+      }
+
+      auto ch = detail::coroutine_handle<promise_type>::from_promise(*coro);
+      if (!ch)
+      {
+        boost::asio::post(exec,
+            [h = std::move(h)]() mutable
+            {
+              h(detail::coro_error<error_type>::invalid());
+            });
+      }
+      else if (ch.done())
+      {
+        boost::asio::post(exec,
+            [h = std::move(h)]() mutable
+            {
+              h(detail::coro_error<error_type>::done());
+            });
+      }
+      else
+      {
+        assert(coro->awaited_from == detail::noop_coroutine());
+        coro->awaited_from =
+          detail::post_coroutine(exec,
+              [coro, h = std::move(h)]() mutable
+              {
+                std::move(h)(std::move(coro->error_));
+              });
+        coro->reset_error();
+        ch.resume();
+      }
+    };
+  }
+
+  template <typename E, typename WaitHandler>
+  auto handle(E exec, WaitHandler&& handler,
+      std::false_type /* error is noexcept */,
+      std::false_type  /* result is void */)
+  {
+    return [coro = coro_,
+        h = std::forward<WaitHandler>(handler),
+        exec = std::move(exec)]() mutable
+    {
+      if (!coro)
+      {
+        boost::asio::post(exec,
+            [h = std::move(h)]() mutable
+            {
+              h(detail::coro_error<error_type>::invalid(), result_type{});
+            });
+        return;
+      }
+
+      auto ch =
+        detail::coroutine_handle<promise_type>::from_promise(*coro);
+      if (!ch)
+      {
+        boost::asio::post(exec,
+            [h = std::move(h)]() mutable
+            {
+              h(detail::coro_error<error_type>::invalid(), result_type{});
+            });
+      }
+      else if (ch.done())
+      {
+        boost::asio::post(exec,
+            [h = std::move(h)]() mutable
+            {
+              h(detail::coro_error<error_type>::done(), result_type{});
+            });
+      }
+      else
+      {
+        assert(coro->awaited_from == detail::noop_coroutine());
+        coro->awaited_from =
+          detail::post_coroutine(exec,
+              [h = std::move(h), coro]() mutable
+              {
+                std::move(h)(
+                    std::move(coro->error_),
+                    std::move(coro->result_));
+              });
+        coro->reset_error();
+        ch.resume();
+      }
+    };
+  }
+
+  template <typename WaitHandler>
+  void operator()(WaitHandler&& handler)
+  {
+    const auto exec = boost::asio::prefer(
+        get_associated_executor(handler, get_executor()),
+        execution::outstanding_work.tracked);
+
+    coro_->cancel = &coro_->cancel_source.emplace();
+    coro_->cancel->state = cancellation_state(
+        coro_->cancel->slot = get_associated_cancellation_slot(handler));
+    boost::asio::dispatch(get_executor(),
+        handle(exec, std::forward<WaitHandler>(handler),
+          std::integral_constant<bool, is_noexcept>{},
+          std::is_void<result_type>{}));
+  }
+
+  template <typename WaitHandler, typename Input>
+  void operator()(WaitHandler&& handler, Input&& input)
+  {
+    const auto exec = boost::asio::prefer(
+        get_associated_executor(handler, get_executor()),
+        execution::outstanding_work.tracked);
+
+    coro_->cancel = &coro_->cancel_source.emplace();
+    coro_->cancel->state = cancellation_state(
+        coro_->cancel->slot = get_associated_cancellation_slot(handler));
+    boost::asio::dispatch(get_executor(),
+        [h = handle(exec, std::forward<WaitHandler>(handler),
+            std::integral_constant<bool, is_noexcept>{},
+            std::is_void<result_type>{}),
+            in = std::forward<Input>(input), coro = coro_]() mutable
+        {
+          coro->input_ = std::move(in);
+          std::move(h)();
+        });
+  }
+
+private:
+  typename coro::promise_type* coro_;
+};
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_IMPL_CORO_HPP
diff --git a/boost/asio/experimental/impl/deferred.hpp b/boost/asio/experimental/impl/deferred.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..1e191d6294cec25a1abe62424be1b13132d82c1e
--- /dev/null
+++ b/boost/asio/experimental/impl/deferred.hpp
@@ -0,0 +1,106 @@
+//
+// experimental/impl/deferred.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_IMPL_DEFERRED_HPP
+#define BOOST_ASIO_EXPERIMENTAL_IMPL_DEFERRED_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename R, typename... Args>
+class async_result<
+    experimental::detail::deferred_signature_probe, R(Args...)>
+{
+public:
+  typedef experimental::detail::deferred_signature_probe_result<void(Args...)>
+    return_type;
+
+  template <typename Initiation, typename... InitArgs>
+  static return_type initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation),
+      experimental::detail::deferred_signature_probe,
+      BOOST_ASIO_MOVE_ARG(InitArgs)...)
+  {
+    return return_type{};
+  }
+};
+
+template <typename Signature>
+class async_result<experimental::deferred_t, Signature>
+{
+public:
+  template <typename Initiation, typename... InitArgs>
+  static experimental::deferred_async_operation<
+      Signature, Initiation, InitArgs...>
+  initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      experimental::deferred_t, BOOST_ASIO_MOVE_ARG(InitArgs)... args)
+  {
+    return experimental::deferred_async_operation<
+        Signature, Initiation, InitArgs...>(
+          experimental::deferred_init_tag{},
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
+          BOOST_ASIO_MOVE_CAST(InitArgs)(args)...);
+    }
+};
+
+template <typename Function, typename R, typename... Args>
+class async_result<
+    experimental::deferred_function<Function>, R(Args...)>
+{
+public:
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate(BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      experimental::deferred_function<Function> token,
+      BOOST_ASIO_MOVE_ARG(InitArgs)... init_args)
+  {
+    return experimental::deferred_sequence<
+        experimental::deferred_async_operation<
+          R(Args...), Initiation, InitArgs...>,
+        Function>(experimental::deferred_init_tag{},
+          experimental::deferred_async_operation<
+            R(Args...), Initiation, InitArgs...>(
+              experimental::deferred_init_tag{},
+              BOOST_ASIO_MOVE_CAST(Initiation)(initiation),
+              BOOST_ASIO_MOVE_CAST(InitArgs)(init_args)...),
+          BOOST_ASIO_MOVE_CAST(Function)(token.function_));
+  }
+};
+
+template <template <typename, typename> class Associator,
+    typename Handler, typename Tail, typename DefaultCandidate>
+struct associator<Associator,
+    experimental::detail::deferred_sequence_handler<Handler, Tail>,
+    DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const experimental::detail::deferred_sequence_handler<Handler, Tail>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_IMPL_DEFERRED_HPP
diff --git a/boost/asio/experimental/impl/parallel_group.hpp b/boost/asio/experimental/impl/parallel_group.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..668a00e4ca7f6b35ade9b535209dfa3408e5935c
--- /dev/null
+++ b/boost/asio/experimental/impl/parallel_group.hpp
@@ -0,0 +1,435 @@
+//
+// experimental/impl/parallel_group.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IMPL_EXPERIMENTAL_PARALLEL_GROUP_HPP
+#define BOOST_ASIO_IMPL_EXPERIMENTAL_PARALLEL_GROUP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <atomic>
+#include <memory>
+#include <new>
+#include <tuple>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/detail/recycling_allocator.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/dispatch.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+// Stores the result from an individual asynchronous operation.
+template <typename T, typename = void>
+struct parallel_group_op_result
+{
+public:
+  parallel_group_op_result()
+    : has_value_(false)
+  {
+  }
+
+  parallel_group_op_result(parallel_group_op_result&& other)
+    : has_value_(other.has_value_)
+  {
+    if (has_value_)
+      new (&u_.value_) T(std::move(other.get()));
+  }
+
+  ~parallel_group_op_result()
+  {
+    if (has_value_)
+      u_.value_.~T();
+  }
+
+  T& get() noexcept
+  {
+    return u_.value_;
+  }
+
+  template <typename... Args>
+  void emplace(Args&&... args)
+  {
+    new (&u_.value_) T(std::forward<Args>(args)...);
+    has_value_ = true;
+  }
+
+private:
+  union u
+  {
+    u() {}
+    ~u() {}
+    char c_;
+    T value_;
+  } u_;
+  bool has_value_;
+};
+
+// Proxy completion handler for the group of parallel operatations. Unpacks and
+// concatenates the individual operations' results, and invokes the user's
+// completion handler.
+template <typename Handler, typename... Ops>
+struct parallel_group_completion_handler
+{
+  typedef typename decay<
+      typename prefer_result<
+        typename associated_executor<Handler>::type,
+        execution::outstanding_work_t::tracked_t
+      >::type
+    >::type executor_type;
+
+  parallel_group_completion_handler(Handler&& h)
+    : handler_(std::move(h)),
+      executor_(
+          boost::asio::prefer(
+            boost::asio::get_associated_executor(handler_),
+            execution::outstanding_work.tracked))
+  {
+  }
+
+  executor_type get_executor() const noexcept
+  {
+    return executor_;
+  }
+
+  void operator()()
+  {
+    this->invoke(std::make_index_sequence<sizeof...(Ops)>());
+  }
+
+  template <std::size_t... I>
+  void invoke(std::index_sequence<I...>)
+  {
+    this->invoke(std::tuple_cat(std::move(std::get<I>(args_).get())...));
+  }
+
+  template <typename... Args>
+  void invoke(std::tuple<Args...>&& args)
+  {
+    this->invoke(std::move(args), std::make_index_sequence<sizeof...(Args)>());
+  }
+
+  template <typename... Args, std::size_t... I>
+  void invoke(std::tuple<Args...>&& args, std::index_sequence<I...>)
+  {
+    std::move(handler_)(completion_order_, std::move(std::get<I>(args))...);
+  }
+
+  Handler handler_;
+  executor_type executor_;
+  std::array<std::size_t, sizeof...(Ops)> completion_order_{};
+  std::tuple<
+      parallel_group_op_result<
+        typename parallel_op_signature_as_tuple<
+          typename parallel_op_signature<Ops>::type
+        >::type
+      >...
+    > args_{};
+};
+
+// Shared state for the parallel group.
+template <typename Condition, typename Handler, typename... Ops>
+struct parallel_group_state
+{
+  parallel_group_state(Condition&& c, Handler&& h)
+    : cancellation_condition_(std::move(c)),
+      handler_(std::move(h))
+  {
+  }
+
+  // The number of operations that have completed so far. Used to determine the
+  // order of completion.
+  std::atomic<unsigned int> completed_{0};
+
+  // The non-none cancellation type that resulted from a cancellation condition.
+  // Stored here for use by the group's initiating function.
+  std::atomic<cancellation_type_t> cancel_type_{cancellation_type::none};
+
+  // The number of cancellations that have been requested, either on completion
+  // of the operations within the group, or via the cancellation slot for the
+  // group operation. Initially set to the number of operations to prevent
+  // cancellation signals from being emitted until after all of the group's
+  // operations' initiating functions have completed.
+  std::atomic<unsigned int> cancellations_requested_{sizeof...(Ops)};
+
+  // The number of operations that are yet to complete. Used to determine when
+  // it is safe to invoke the user's completion handler.
+  std::atomic<unsigned int> outstanding_{sizeof...(Ops)};
+
+  // The cancellation signals for each operation in the group.
+  boost::asio::cancellation_signal cancellation_signals_[sizeof...(Ops)];
+
+  // The cancellation condition is used to determine whether the results from an
+  // individual operation warrant a cancellation request for the whole group.
+  Condition cancellation_condition_;
+
+  // The proxy handler to be invoked once all operations in the group complete.
+  parallel_group_completion_handler<Handler, Ops...> handler_;
+};
+
+// Handler for an individual operation within the parallel group.
+template <std::size_t I, typename Condition, typename Handler, typename... Ops>
+struct parallel_group_op_handler
+{
+  typedef boost::asio::cancellation_slot cancellation_slot_type;
+
+  parallel_group_op_handler(
+    std::shared_ptr<parallel_group_state<Condition, Handler, Ops...> > state)
+    : state_(std::move(state))
+  {
+  }
+
+  cancellation_slot_type get_cancellation_slot() const noexcept
+  {
+    return state_->cancellation_signals_[I].slot();
+  }
+
+  template <typename... Args>
+  void operator()(Args... args)
+  {
+    // Capture this operation into the completion order.
+    state_->handler_.completion_order_[state_->completed_++] = I;
+
+    // Determine whether the results of this operation require cancellation of
+    // the whole group.
+    cancellation_type_t cancel_type = state_->cancellation_condition_(args...);
+
+    // Capture the result of the operation into the proxy completion handler.
+    std::get<I>(state_->handler_.args_).emplace(std::move(args)...);
+
+    if (cancel_type != cancellation_type::none)
+    {
+      // Save the type for potential use by the group's initiating function.
+      state_->cancel_type_ = cancel_type;
+
+      // If we are the first operation to request cancellation, emit a signal
+      // for each operation in the group.
+      if (state_->cancellations_requested_++ == 0)
+        for (std::size_t i = 0; i < sizeof...(Ops); ++i)
+          if (i != I)
+            state_->cancellation_signals_[i].emit(cancel_type);
+    }
+
+    // If this is the last outstanding operation, invoke the user's handler.
+    if (--state_->outstanding_ == 0)
+      boost::asio::dispatch(std::move(state_->handler_));
+  }
+
+  std::shared_ptr<parallel_group_state<Condition, Handler, Ops...> > state_;
+};
+
+// Handler for an individual operation within the parallel group that has an
+// explicitly specified executor.
+template <typename Executor, std::size_t I,
+    typename Condition, typename Handler, typename... Ops>
+struct parallel_group_op_handler_with_executor :
+  parallel_group_op_handler<I, Condition, Handler, Ops...>
+{
+  typedef parallel_group_op_handler<I, Condition, Handler, Ops...> base_type;
+  typedef boost::asio::cancellation_slot cancellation_slot_type;
+  typedef Executor executor_type;
+
+  parallel_group_op_handler_with_executor(
+      std::shared_ptr<parallel_group_state<Condition, Handler, Ops...> > state,
+      executor_type ex)
+    : parallel_group_op_handler<I, Condition, Handler, Ops...>(std::move(state))
+  {
+    cancel_proxy_ =
+      &this->state_->cancellation_signals_[I].slot().template
+        emplace<cancel_proxy>(this->state_, std::move(ex));
+  }
+
+  cancellation_slot_type get_cancellation_slot() const noexcept
+  {
+    return cancel_proxy_->signal_.slot();
+  }
+
+  executor_type get_executor() const noexcept
+  {
+    return cancel_proxy_->executor_;
+  }
+
+  // Proxy handler that forwards the emitted signal to the correct executor.
+  struct cancel_proxy
+  {
+    cancel_proxy(
+        std::shared_ptr<parallel_group_state<
+          Condition, Handler, Ops...> > state,
+        executor_type ex)
+      : state_(std::move(state)),
+        executor_(std::move(ex))
+    {
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+      if (auto state = state_.lock())
+      {
+        boost::asio::cancellation_signal* sig = &signal_;
+        boost::asio::dispatch(executor_,
+            [state, sig, type]{ sig->emit(type); });
+      }
+    }
+
+    std::weak_ptr<parallel_group_state<Condition, Handler, Ops...> > state_;
+    boost::asio::cancellation_signal signal_;
+    executor_type executor_;
+  };
+
+  cancel_proxy* cancel_proxy_;
+};
+
+// Helper to launch an operation using the correct executor, if any.
+template <std::size_t I, typename Op, typename = void>
+struct parallel_group_op_launcher
+{
+  template <typename Condition, typename Handler, typename... Ops>
+  static void launch(Op& op,
+    const std::shared_ptr<parallel_group_state<
+      Condition, Handler, Ops...> >& state)
+  {
+    typedef typename associated_executor<Op>::type ex_type;
+    ex_type ex = boost::asio::get_associated_executor(op);
+    std::move(op)(
+        parallel_group_op_handler_with_executor<ex_type, I,
+          Condition, Handler, Ops...>(state, std::move(ex)));
+  }
+};
+
+// Specialised launcher for operations that specify no executor.
+template <std::size_t I, typename Op>
+struct parallel_group_op_launcher<I, Op,
+    typename enable_if<
+      is_same<
+        typename associated_executor<
+          Op>::asio_associated_executor_is_unspecialised,
+        void
+      >::value
+    >::type>
+{
+  template <typename Condition, typename Handler, typename... Ops>
+  static void launch(Op& op,
+    const std::shared_ptr<parallel_group_state<
+      Condition, Handler, Ops...> >& state)
+  {
+    std::move(op)(
+        parallel_group_op_handler<I, Condition, Handler, Ops...>(state));
+  }
+};
+
+template <typename Condition, typename Handler, typename... Ops>
+struct parallel_group_cancellation_handler
+{
+  parallel_group_cancellation_handler(
+    std::shared_ptr<parallel_group_state<Condition, Handler, Ops...> > state)
+    : state_(std::move(state))
+  {
+  }
+
+  void operator()(cancellation_type_t cancel_type)
+  {
+    // If we are the first place to request cancellation, i.e. no operation has
+    // yet completed and requested cancellation, emit a signal for each
+    // operation in the group.
+    if (cancel_type != cancellation_type::none)
+      if (auto state = state_.lock())
+        if (state->cancellations_requested_++ == 0)
+          for (std::size_t i = 0; i < sizeof...(Ops); ++i)
+            state->cancellation_signals_[i].emit(cancel_type);
+  }
+
+  std::weak_ptr<parallel_group_state<Condition, Handler, Ops...> > state_;
+};
+
+template <typename Condition, typename Handler,
+    typename... Ops, std::size_t... I>
+void parallel_group_launch(Condition cancellation_condition, Handler handler,
+    std::tuple<Ops...>& ops, std::index_sequence<I...>)
+{
+  // Get the user's completion handler's cancellation slot, so that we can allow
+  // cancellation of the entire group.
+  typename associated_cancellation_slot<Handler>::type slot
+    = boost::asio::get_associated_cancellation_slot(handler);
+
+  // Create the shared state for the operation.
+  typedef parallel_group_state<Condition, Handler, Ops...> state_type;
+  std::shared_ptr<state_type> state = std::allocate_shared<state_type>(
+      boost::asio::detail::recycling_allocator<state_type,
+        boost::asio::detail::thread_info_base::parallel_group_tag>(),
+      std::move(cancellation_condition), std::move(handler));
+
+  // Initiate each individual operation in the group.
+  int fold[] = { 0,
+    ( parallel_group_op_launcher<I, Ops>::launch(std::get<I>(ops), state),
+      0 )...
+  };
+  (void)fold;
+
+  // Check if any of the operations has already requested cancellation, and if
+  // so, emit a signal for each operation in the group.
+  if ((state->cancellations_requested_ -= sizeof...(Ops)) > 0)
+    for (auto& signal : state->cancellation_signals_)
+      signal.emit(state->cancel_type_);
+
+  // Register a handler with the user's completion handler's cancellation slot.
+  if (slot.is_connected())
+    slot.template emplace<
+      parallel_group_cancellation_handler<
+        Condition, Handler, Ops...> >(state);
+}
+
+} // namespace detail
+} // namespace experimental
+
+template <typename R, typename... Args>
+class async_result<
+    experimental::detail::parallel_op_signature_probe,
+    R(Args...)>
+{
+public:
+  typedef experimental::detail::parallel_op_signature_probe_result<
+    void(Args...)> return_type;
+
+  template <typename Initiation, typename... InitArgs>
+  static return_type initiate(Initiation&&,
+      experimental::detail::parallel_op_signature_probe, InitArgs&&...)
+  {
+    return return_type{};
+  }
+};
+
+template <template <typename, typename> class Associator,
+    typename Handler, typename... Ops, typename DefaultCandidate>
+struct associator<Associator,
+    experimental::detail::parallel_group_completion_handler<Handler, Ops...>,
+    DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const experimental::detail::parallel_group_completion_handler<
+        Handler, Ops...>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_EXPERIMENTAL_PARALLEL_GROUP_HPP
diff --git a/boost/asio/experimental/impl/prepend.hpp b/boost/asio/experimental/impl/prepend.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..fa3f502b62aaa317d4a4d21bbf3bd485f3802220
--- /dev/null
+++ b/boost/asio/experimental/impl/prepend.hpp
@@ -0,0 +1,219 @@
+//
+// experimental/impl/prepend.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IMPL_EXPERIMENTAL_PREPEND_HPP
+#define BOOST_ASIO_IMPL_EXPERIMENTAL_PREPEND_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <boost/asio/associator.hpp>
+#include <boost/asio/async_result.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/type_traits.hpp>
+#include <boost/asio/detail/variadic_templates.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+// Class to adapt a prepend_t as a completion handler.
+template <typename Handler, typename... Values>
+class prepend_handler
+{
+public:
+  typedef void result_type;
+
+  template <typename H>
+  prepend_handler(BOOST_ASIO_MOVE_ARG(H) handler, std::tuple<Values...> values)
+    : handler_(BOOST_ASIO_MOVE_CAST(H)(handler)),
+      values_(BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(values))
+  {
+  }
+
+  template <typename... Args>
+  void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    this->invoke(
+        std::make_index_sequence<sizeof...(Values)>{},
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+  template <std::size_t... I, typename... Args>
+  void invoke(std::index_sequence<I...>, BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        BOOST_ASIO_MOVE_CAST(Values)(std::get<I>(values_))...,
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+
+//private:
+  Handler handler_;
+  std::tuple<Values...> values_;
+};
+
+template <typename Handler>
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
+    prepend_handler<Handler>* this_handler)
+{
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
+  return boost_asio_handler_alloc_helpers::allocate(
+      size, this_handler->handler_);
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
+    prepend_handler<Handler>* this_handler)
+{
+  boost_asio_handler_alloc_helpers::deallocate(
+      pointer, size, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler>
+inline bool asio_handler_is_continuation(
+    prepend_handler<Handler>* this_handler)
+{
+  return boost_asio_handler_cont_helpers::is_continuation(
+        this_handler->handler_);
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
+    prepend_handler<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Function, typename Handler>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
+    prepend_handler<Handler>* this_handler)
+{
+  boost_asio_handler_invoke_helpers::invoke(
+      function, this_handler->handler_);
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+}
+
+template <typename Signature, typename... Values>
+struct prepend_signature;
+
+template <typename R, typename... Args, typename... Values>
+struct prepend_signature<R(Args...), Values...>
+{
+  typedef R type(Values..., typename decay<Args>::type...);
+};
+
+} // namespace detail
+} // namespace experimental
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename CompletionToken, typename... Values, typename Signature>
+struct async_result<
+    experimental::prepend_t<CompletionToken, Values...>, Signature>
+  : async_result<CompletionToken,
+      typename experimental::detail::prepend_signature<
+        Signature, Values...>::type>
+{
+  typedef typename experimental::detail::prepend_signature<
+      Signature, Values...>::type signature;
+
+  template <typename Initiation>
+  struct init_wrapper
+  {
+    init_wrapper(Initiation init)
+      : initiation_(BOOST_ASIO_MOVE_CAST(Initiation)(init))
+    {
+    }
+
+    template <typename Handler, typename... Args>
+    void operator()(
+        BOOST_ASIO_MOVE_ARG(Handler) handler,
+        std::tuple<Values...> values,
+        BOOST_ASIO_MOVE_ARG(Args)... args)
+    {
+      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
+          experimental::detail::prepend_handler<
+            typename decay<Handler>::type, Values...>(
+              BOOST_ASIO_MOVE_CAST(Handler)(handler),
+              BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(values)),
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    }
+
+    Initiation initiation_;
+  };
+
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, signature,
+      (async_initiate<CompletionToken, signature>(
+        declval<init_wrapper<typename decay<Initiation>::type> >(),
+        declval<CompletionToken&>(),
+        declval<std::tuple<Values...> >(),
+        declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))
+  initiate(
+      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
+      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
+      BOOST_ASIO_MOVE_ARG(Args)... args)
+  {
+    return async_initiate<CompletionToken, signature>(
+        init_wrapper<typename decay<Initiation>::type>(
+          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
+        token.token_,
+        BOOST_ASIO_MOVE_CAST(std::tuple<Values...>)(token.values_),
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
+  }
+};
+
+template <template <typename, typename> class Associator,
+    typename Handler, typename... Values, typename DefaultCandidate>
+struct associator<Associator,
+    experimental::detail::prepend_handler<Handler, Values...>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const experimental::detail::prepend_handler<Handler, Values...>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_EXPERIMENTAL_PREPEND_HPP
diff --git a/boost/asio/experimental/impl/promise.hpp b/boost/asio/experimental/impl/promise.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..0d7dbeab1e11e8ed8348cd3bac390a1ca95676ba
--- /dev/null
+++ b/boost/asio/experimental/impl/promise.hpp
@@ -0,0 +1,104 @@
+//
+// experimental/impl/promise.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_ASIO_EXPERIMENTAL_IMPL_PROMISE_HPP
+#define BOOST_ASIO_EXPERIMENTAL_IMPL_PROMISE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/cancellation_signal.hpp>
+#include <boost/asio/experimental/detail/completion_handler_erasure.hpp>
+#include <tuple>
+#include <optional>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+template<typename Signature = void(), typename Executor = any_io_executor>
+struct promise;
+
+namespace detail {
+
+template<typename Signature, typename Executor>
+struct promise_impl;
+
+template<typename ... Ts, typename Executor>
+struct promise_impl<void(Ts...), Executor>
+{
+  using result_type = std::tuple<Ts...>;
+
+  promise_impl(Executor executor = {})
+    : executor(std::move(executor))
+  {
+  }
+
+  std::optional<result_type> result;
+  bool done{false};
+  detail::completion_handler_erasure<void(Ts...), Executor> completion;
+  cancellation_signal cancel;
+  Executor executor;
+};
+
+template<typename Signature = void(), typename Executor = any_io_executor>
+struct promise_handler;
+
+template<typename Signature, typename Executor>
+struct promise_handler;
+
+template<typename ... Ts, typename Executor>
+struct promise_handler<void(Ts...), Executor>
+{
+  using promise_type = promise<void(Ts...), Executor>;
+
+  promise_handler(Executor executor) // get_associated_allocator(exec)
+    : impl_{
+        std::allocate_shared<promise_impl<void(Ts...), Executor>>(
+          get_associated_allocator(executor))}
+  {
+    impl_->executor = std::move(executor);
+  }
+
+  std::shared_ptr<promise_impl<void(Ts...), Executor>> impl_;
+
+  using cancellation_slot_type = cancellation_slot;
+
+  cancellation_slot_type get_cancellation_slot() const noexcept
+  {
+    return impl_->cancel.slot();
+  }
+
+  auto make_promise() -> promise<void(Ts...), Executor>
+  {
+    return {impl_};
+  }
+
+  void operator()(std::remove_reference_t<Ts>... ts)
+  {
+    assert(impl_);
+    impl_->result.emplace(std::move(ts)...);
+    impl_->done = true;
+    if (auto f = std::exchange(impl_->completion, nullptr); f != nullptr)
+      std::apply(std::move(f), std::move(*impl_->result));
+  }
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_IMPL_PROMISE_HPP
diff --git a/boost/asio/experimental/impl/use_coro.hpp b/boost/asio/experimental/impl/use_coro.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..5a02f57c31be0d79ffa192df04409ce5cfe9093b
--- /dev/null
+++ b/boost/asio/experimental/impl/use_coro.hpp
@@ -0,0 +1,270 @@
+//
+// experimental/impl/use_coro.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_IMPL_USE_CORO_HPP
+#define BOOST_ASIO_EXPERIMENTAL_IMPL_USE_CORO_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+template <typename Yield, typename Return, typename Executor>
+struct coro;
+
+namespace detail {
+
+template <typename Yield, typename Return, typename Executor>
+struct coro_promise;
+
+template <typename Executor, typename... Ts>
+struct coro_init_handler
+{
+  struct handler_t
+  {
+  };
+
+  constexpr static handler_t handler{};
+
+  struct init_helper;
+
+  struct promise_type
+  {
+    auto initial_suspend() noexcept { return suspend_always{}; }
+
+    auto final_suspend() noexcept { return suspend_always(); }
+
+    void return_void() {}
+
+    void unhandled_exception() { assert(false); }
+
+    auto await_transform(handler_t)
+    {
+      assert(executor);
+      assert(h);
+      return init_helper{this};
+    }
+
+    std::optional<Executor> executor;
+    std::optional<std::tuple<Ts...>> result;
+    coroutine_handle<> h;
+
+    coro_init_handler get_return_object() { return coro_init_handler{this}; }
+
+    cancellation_slot cancel_slot;
+  };
+
+  struct init_helper
+  {
+    promise_type *self_;
+
+    constexpr static bool await_ready() noexcept { return true; }
+
+    constexpr static void await_suspend(coroutine_handle<>) noexcept {}
+
+    auto await_resume() const noexcept
+    {
+      assert(self_);
+      return bind_cancellation_slot(self_->cancel_slot,
+          bind_executor(*self_->executor, [self = self_](Ts... ts)
+          {
+            self->cancel_slot.clear();
+            self->result.emplace(std::move(ts)...);
+            self->h.resume();
+          }));
+    }
+  };
+
+  promise_type* promise;
+
+  void unhandled_exception() noexcept
+  {
+    throw;
+  }
+
+  struct noexcept_version
+  {
+    promise_type *promise;
+
+    constexpr static bool await_ready() noexcept { return false; }
+
+    template <typename Yield, typename Return,
+        convertible_to<Executor> Executor1>
+    auto await_suspend(
+        coroutine_handle<coro_promise<Yield, Return, Executor1> > h) noexcept
+    {
+      promise->executor = h.promise().get_executor();
+      promise->h = h;
+      return coroutine_handle<promise_type>::from_promise(*promise);
+    }
+
+    template <typename... Args>
+    static auto resume_impl(std::tuple<Args...>&& tup)
+    {
+      return std::move(tup);
+    }
+
+    template <typename Arg>
+    static auto resume_impl(std::tuple<Arg>&& tup)
+    {
+      return get<0>(std::move(tup));
+    }
+
+    static void resume_impl(std::tuple<>&&) {}
+
+    auto await_resume() const noexcept
+    {
+      auto res = std::move(promise->result.value());
+      coroutine_handle<promise_type>::from_promise(*promise).destroy();
+      return resume_impl(std::move(res));
+    }
+  };
+
+  struct throwing_version
+  {
+    promise_type *promise;
+
+    constexpr static bool await_ready() noexcept { return false; }
+
+    template <typename Yield, typename Return,
+        convertible_to<Executor> Executor1>
+    auto await_suspend(
+        coroutine_handle<coro_promise<Yield, Return, Executor1> > h) noexcept
+    {
+      promise->executor = h.promise().get_executor();
+      promise->h = h;
+      return coroutine_handle<promise_type>::from_promise(*promise);
+    }
+
+    template <typename... Args>
+    static auto resume_impl(std::tuple<Args...>&& tup)
+    {
+      return std::move(tup);
+    }
+
+    static void resume_impl(std::tuple<>&&) {}
+
+    template <typename Arg>
+    static auto resume_impl(std::tuple<Arg>&& tup)
+    {
+      return get<0>(std::move(tup));
+    }
+
+    template <typename... Args>
+    static auto resume_impl(std::tuple<std::exception_ptr, Args...>&& tup)
+    {
+      auto ex = get<0>(std::move(tup));
+      if (ex)
+        std::rethrow_exception(ex);
+
+      if constexpr (sizeof...(Args) == 0u)
+        return;
+      else if constexpr (sizeof...(Args) == 1u)
+        return get<1>(std::move(tup));
+      else
+      {
+        return
+          [&]<std::size_t... Idx>(std::index_sequence<Idx...>)
+          {
+            return std::make_tuple(std::get<Idx + 1>(std::move(tup))...);
+          }(std::make_index_sequence<sizeof...(Args) - 1>{});
+      }
+    }
+
+    template <typename... Args>
+    static auto resume_impl(
+        std::tuple<boost::system::error_code, Args...>&& tup)
+    {
+      auto ec = get<0>(std::move(tup));
+      if (ec)
+        boost::asio::detail::throw_exception(
+            boost::system::system_error(ec, "error_code in use_coro"));
+
+      if constexpr (sizeof...(Args) == 0u)
+        return;
+      else if constexpr (sizeof...(Args) == 1u)
+        return get<1>(std::move(tup));
+      else
+        return
+          [&]<std::size_t... Idx>(std::index_sequence<Idx...>)
+          {
+            return std::make_tuple(std::get<Idx + 1>(std::move(tup))...);
+          }(std::make_index_sequence<sizeof...(Args) - 1>{});
+    }
+
+    static auto resume_impl(std::tuple<std::exception_ptr>&& tup)
+    {
+      auto ex = get<0>(std::move(tup));
+      if (ex)
+        std::rethrow_exception(ex);
+    }
+
+    static auto resume_impl(
+        std::tuple<boost::system::error_code>&& tup)
+    {
+      auto ec = get<0>(std::move(tup));
+      if (ec)
+        boost::asio::detail::throw_error(ec, "error_code in use_coro");
+    }
+
+    auto await_resume() const
+    {
+      auto res = std::move(promise->result.value());
+      coroutine_handle<promise_type>::from_promise(*promise).destroy();
+      return resume_impl(std::move(res));
+    }
+  };
+
+  auto as_noexcept(cancellation_slot&& sl) && noexcept
+  {
+    promise->cancel_slot = std::move(sl);
+    return noexcept_version{promise};
+  }
+
+  auto as_throwing(cancellation_slot&& sl) && noexcept
+  {
+    promise->cancel_slot = std::move(sl);
+    return throwing_version{promise};
+  }
+};
+
+} // namespace detail
+} // namespace experimental
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename Executor, typename R, typename... Args>
+struct async_result<experimental::use_coro_t<Executor>, R(Args...)>
+{
+  using return_type = experimental::detail::coro_init_handler<
+    Executor, typename decay<Args>::type...>;
+
+  template <typename Initiation, typename... InitArgs>
+  static return_type initiate(Initiation initiation,
+      experimental::use_coro_t<Executor>, InitArgs... args)
+  {
+    std::move(initiation)(co_await return_type::handler, std::move(args)...);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_IMPL_USE_CORO_HPP
diff --git a/boost/asio/experimental/parallel_group.hpp b/boost/asio/experimental/parallel_group.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..cd5431084e8d7c303009c270b734a9c41aa0c56b
--- /dev/null
+++ b/boost/asio/experimental/parallel_group.hpp
@@ -0,0 +1,218 @@
+//
+// experimental/parallel_group.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_PARALLEL_GROUP_HPP
+#define BOOST_ASIO_EXPERIMENTAL_PARALLEL_GROUP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <utility>
+#include <boost/asio/detail/array.hpp>
+#include <boost/asio/experimental/cancellation_condition.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+// Helper trait for getting the completion signature from an async operation.
+
+struct parallel_op_signature_probe {};
+
+template <typename T>
+struct parallel_op_signature_probe_result
+{
+  typedef T type;
+};
+
+template <typename Op>
+struct parallel_op_signature
+{
+  typedef typename decltype(declval<Op>()(
+    declval<parallel_op_signature_probe>()))::type type;
+};
+
+// Helper trait for getting a tuple from a completion signature.
+
+template <typename Signature>
+struct parallel_op_signature_as_tuple;
+
+template <typename R, typename... Args>
+struct parallel_op_signature_as_tuple<R(Args...)>
+{
+  typedef std::tuple<typename decay<Args>::type...> type;
+};
+
+// Helper trait for concatenating completion signatures.
+
+template <std::size_t N, typename Offsets, typename... Signatures>
+struct parallel_group_signature;
+
+template <std::size_t N, typename R0, typename... Args0>
+struct parallel_group_signature<N, R0(Args0...)>
+{
+  typedef boost::asio::detail::array<std::size_t, N> order_type;
+  typedef R0 raw_type(Args0...);
+  typedef R0 type(order_type, Args0...);
+};
+
+template <std::size_t N,
+    typename R0, typename... Args0,
+    typename R1, typename... Args1>
+struct parallel_group_signature<N, R0(Args0...), R1(Args1...)>
+{
+  typedef boost::asio::detail::array<std::size_t, N> order_type;
+  typedef R0 raw_type(Args0..., Args1...);
+  typedef R0 type(order_type, Args0..., Args1...);
+};
+
+template <std::size_t N, typename Sig0,
+    typename Sig1, typename... SigN>
+struct parallel_group_signature<N, Sig0, Sig1, SigN...>
+{
+  typedef boost::asio::detail::array<std::size_t, N> order_type;
+  typedef typename parallel_group_signature<N,
+    typename parallel_group_signature<N, Sig0, Sig1>::raw_type,
+      SigN...>::raw_type raw_type;
+  typedef typename parallel_group_signature<N,
+    typename parallel_group_signature<N, Sig0, Sig1>::raw_type,
+      SigN...>::type type;
+};
+
+template <typename Condition, typename Handler,
+    typename... Ops, std::size_t... I>
+void parallel_group_launch(Condition cancellation_condition, Handler handler,
+    std::tuple<Ops...>& ops, std::index_sequence<I...>);
+
+} // namespace detail
+
+/// A group of asynchronous operations that may be launched in parallel.
+/**
+ * See the documentation for boost::asio::experimental::make_parallel_group for
+ * a usage example.
+ */
+template <typename... Ops>
+class parallel_group
+{
+public:
+  /// Constructor.
+  explicit parallel_group(Ops... ops)
+    : ops_(std::move(ops)...)
+  {
+  }
+
+  /// The completion signature for the group of operations.
+  typedef typename detail::parallel_group_signature<sizeof...(Ops),
+      typename detail::parallel_op_signature<Ops>::type...>::type signature;
+
+  /// Initiate an asynchronous wait for the group of operations.
+  /**
+   * Launches the group and asynchronously waits for completion.
+   *
+   * @param cancellation_condition A function object, called on completion of
+   * an operation within the group, that is used to determine whether to cancel
+   * the remaining operations. The function object is passed the arguments of
+   * the completed operation's handler. To trigger cancellation of the remaining
+   * operations, it must return a boost::asio::cancellation_type value other
+   * than <tt>boost::asio::cancellation_type::none</tt>.
+   *
+   * @param token A completion token whose signature is comprised of
+   * a @c std::array<std::size_t, N> indicating the completion order of the
+   * operations, followed by all operations' completion handler arguments.
+   *
+   * The library provides the following @c cancellation_condition types:
+   *
+   * @li boost::asio::experimental::wait_for_all
+   * @li boost::asio::experimental::wait_for_one
+   * @li boost::asio::experimental::wait_for_one_error
+   * @li boost::asio::experimental::wait_for_one_success
+   */
+  template <typename CancellationCondition,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(signature) CompletionToken>
+  auto async_wait(CancellationCondition cancellation_condition,
+      CompletionToken&& token)
+  {
+    return boost::asio::async_initiate<CompletionToken, signature>(
+        initiate_async_wait(), token,
+        std::move(cancellation_condition), std::move(ops_));
+  }
+
+private:
+  struct initiate_async_wait
+  {
+    template <typename Handler, typename Condition>
+    void operator()(Handler&& h, Condition&& c, std::tuple<Ops...>&& ops) const
+    {
+      detail::parallel_group_launch(std::move(c), std::move(h),
+          ops, std::make_index_sequence<sizeof...(Ops)>());
+    }
+  };
+
+  std::tuple<Ops...> ops_;
+};
+
+/// Create a group of operations that may be launched in parallel.
+/**
+ * For example:
+ * @code boost::asio::experimental::make_parallel_group(
+ *    [&](auto token)
+ *    {
+ *      return in.async_read_some(boost::asio::buffer(data), token);
+ *    },
+ *    [&](auto token)
+ *    {
+ *      return timer.async_wait(token);
+ *    }
+ *  ).async_wait(
+ *    boost::asio::experimental::wait_for_all(),
+ *    [](
+ *        std::array<std::size_t, 2> completion_order,
+ *        boost::system::error_code ec1, std::size_t n1,
+ *        boost::system::error_code ec2
+ *    )
+ *    {
+ *      switch (completion_order[0])
+ *      {
+ *      case 0:
+ *        {
+ *          std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
+ *        }
+ *        break;
+ *      case 1:
+ *        {
+ *          std::cout << "timer finished: " << ec2 << "\n";
+ *        }
+ *        break;
+ *      }
+ *    }
+ *  );
+ * @endcode
+ */
+template <typename... Ops>
+BOOST_ASIO_NODISCARD inline parallel_group<Ops...>
+make_parallel_group(Ops... ops)
+{
+  return parallel_group<Ops...>(std::move(ops)...);
+}
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/experimental/impl/parallel_group.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_PARALLEL_GROUP_HPP
diff --git a/boost/asio/experimental/prepend.hpp b/boost/asio/experimental/prepend.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..6761f1ed28e305c5f82b371a23945c7b8cfe2119
--- /dev/null
+++ b/boost/asio/experimental/prepend.hpp
@@ -0,0 +1,73 @@
+//
+// experimental/prepend.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_PREPEND_HPP
+#define BOOST_ASIO_EXPERIMENTAL_PREPEND_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <tuple>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+/// Completion token type used to specify that the completion handler
+/// arguments should be passed additional values before the results of the
+/// operation.
+template <typename CompletionToken, typename... Values>
+class prepend_t
+{
+public:
+  /// Constructor.
+  template <typename T, typename... V>
+  BOOST_ASIO_CONSTEXPR explicit prepend_t(
+      BOOST_ASIO_MOVE_ARG(T) completion_token,
+      BOOST_ASIO_MOVE_ARG(V)... values)
+    : token_(BOOST_ASIO_MOVE_CAST(T)(completion_token)),
+      values_(BOOST_ASIO_MOVE_CAST(V)(values)...)
+  {
+  }
+
+//private:
+  CompletionToken token_;
+  std::tuple<Values...> values_;
+};
+
+/// Completion token type used to specify that the completion handler
+/// arguments should be passed additional values before the results of the
+/// operation.
+template <typename CompletionToken, typename... Values>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONSTEXPR prepend_t<
+  typename decay<CompletionToken>::type, typename decay<Values>::type...>
+prepend(BOOST_ASIO_MOVE_ARG(CompletionToken) completion_token,
+    BOOST_ASIO_MOVE_ARG(Values)... values)
+{
+  return prepend_t<
+    typename decay<CompletionToken>::type, typename decay<Values>::type...>(
+      BOOST_ASIO_MOVE_CAST(CompletionToken)(completion_token),
+      BOOST_ASIO_MOVE_CAST(Values)(values)...);
+}
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/experimental/impl/prepend.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_PREPEND_HPP
diff --git a/boost/asio/experimental/promise.hpp b/boost/asio/experimental/promise.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..5f8812d7d84726b73d842f97e22da2bf0303c63e
--- /dev/null
+++ b/boost/asio/experimental/promise.hpp
@@ -0,0 +1,613 @@
+//
+// experimental/promise.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_PROMISE_HPP
+#define BOOST_ASIO_EXPERIMENTAL_PROMISE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/bind_executor.hpp>
+#include <boost/asio/cancellation_signal.hpp>
+#include <boost/asio/experimental/detail/completion_handler_erasure.hpp>
+#include <boost/asio/experimental/impl/promise.hpp>
+#include <boost/asio/post.hpp>
+
+#include <algorithm>
+#include <variant>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+template <typename Executor = any_io_executor>
+struct use_promise_t {};
+
+constexpr use_promise_t<> use_promise;
+
+template <typename T>
+struct is_promise : std::false_type {};
+
+template <typename ... Ts>
+struct is_promise<promise<Ts...>> : std::true_type {};
+
+template <typename T>
+constexpr bool is_promise_v = is_promise<T>::value;
+
+template <typename T>
+concept is_promise_c = is_promise_v<std::remove_reference_t<T>>;
+
+template <typename ... Ts>
+struct promise_value_type
+{
+  using type = std::tuple<Ts...>;
+};
+
+template <typename T>
+struct promise_value_type<T>
+{
+  using type = T;
+};
+
+template <>
+struct promise_value_type<>
+{
+  using type = std::monostate;
+};
+
+#if defined(GENERATING_DOCUMENTATION)
+/// The primary template is not defined.
+template<typename Signature = void(), typename Executor = any_io_executor>
+struct promise
+{
+};
+#endif // defined(GENERATING_DOCUMENTATION)
+
+template <typename ... Ts, typename Executor>
+struct promise<void(Ts...), Executor>
+{
+  using value_type = typename promise_value_type<Ts...>::type;
+  using tuple_type = std::tuple<Ts...>;
+  using executor_type = Executor;
+
+  executor_type get_executor() const
+  {
+    if (impl_)
+      return impl_->executor;
+    else
+      return {};
+  }
+
+  void cancel(cancellation_type level = cancellation_type::all)
+  {
+    if (impl_ && !impl_->done)
+    {
+      boost::asio::dispatch(impl_->executor,
+          [level, impl = impl_]{impl->cancel.emit(level);});
+    }
+  }
+
+  bool complete() const noexcept
+  {
+    return impl_ && impl_->done;
+  }
+
+  template <typename CompletionToken>
+  auto async_wait(CompletionToken&& token)
+  {
+    assert(impl_);
+
+    return async_initiate<CompletionToken, void(Ts...)>(
+        initiate_async_wait{impl_}, token);
+  }
+
+  promise() = delete;
+  promise(const promise& ) = delete;
+  promise(promise&& ) noexcept = default;
+
+  ~promise() { cancel(); }
+
+  template <execution::executor Executor1, is_promise_c ... Ps>
+  static auto race(Executor1 exec, Ps ... ps)
+    -> promise<void(std::variant<typename Ps::value_type...>), Executor1>
+  {
+    using var_t = std::variant<typename Ps::value_type...>;
+    using pi = detail::promise_impl<void(var_t), Executor1>;
+
+    struct impl_t : pi
+    {
+      impl_t(Executor1 exec, Ps&& ... ps)
+        : pi(std::move(exec)),
+          tup(std::move(ps)...)
+      {
+        this->slot.template emplace<cancel_handler>(this);
+      }
+
+      struct cancel_handler
+      {
+        impl_t* self;
+
+        cancel_handler(impl_t* self)
+          : self(self)
+        {
+        }
+
+        void operator()(cancellation_type ct)
+        {
+          [ct, s=self]<std::size_t... Idx>(std::index_sequence<Idx...>)
+          {
+            (std::get<Idx>(s->tup).cancel(ct), ... );
+          }(std::make_index_sequence<sizeof...(Ps)>{});
+        }
+      };
+
+      std::tuple<std::remove_reference_t<Ps>...> tup;
+      cancellation_slot slot{this->cancel.slot()};
+    };
+
+    auto impl = std::allocate_shared<impl_t>(
+        get_associated_allocator(exec), exec, std::move(ps)...);
+
+    impl->executor = exec;
+
+    [impl, exec]<std::size_t... Idx>(std::index_sequence<Idx...>)
+    {
+      auto step =
+        [&]<std::size_t I>(std::integral_constant<std::size_t, I>)
+        {
+          return [impl]<typename... Args > (Args&& ... args)
+          {
+            if (impl->done)
+              return;
+            impl->result = var_t(std::in_place_index<I>,
+                std::forward<Args>(args)...);
+            impl->done = true;
+            if (auto f = std::exchange(impl->completion, nullptr); !!f)
+              std::apply(std::move(f), std::move(*impl->result));
+
+            auto cancel =
+              [&]<std::size_t Id>(std::integral_constant<std::size_t, Id>)
+              {
+                if constexpr (I != Id)
+                  get<I>(impl->tup).cancel();
+              };
+
+            (cancel(std::integral_constant<std::size_t, Idx>{}), ...);
+          };
+        };
+
+      (
+        std::get<Idx>(impl->tup).async_wait(
+          bind_executor(exec,
+            step(std::integral_constant<std::size_t, Idx>{}))),
+        ...
+      );
+    }(std::make_index_sequence<sizeof...(Ps)>{});
+
+    return {impl};
+  }
+
+  template <execution::executor Executor1, is_promise_c ... Ps>
+  static auto all(Executor1 exec, Ps ... ps)
+    -> promise<void(typename Ps::value_type...), Executor1>
+  {
+    using pi = detail::promise_impl<
+        void(typename Ps::value_type...), Executor1>;
+
+    struct impl_t : pi
+    {
+      impl_t(Executor1 exec, Ps&& ... ps)
+        : pi(std::move(exec)),
+          tup(std::move(ps)...)
+      {
+        this->slot.template emplace<cancel_handler>(this);
+      }
+
+      struct cancel_handler
+      {
+        impl_t* self;
+
+        cancel_handler(impl_t* self)
+          : self(self)
+        {
+        }
+
+        void operator()(cancellation_type level)
+        {
+          [level, s=self]<std::size_t... Idx>(std::index_sequence<Idx...>)
+          {
+            (std::get<Idx>(s->tup).cancel(level), ... );
+          }(std::make_index_sequence<sizeof...(Ps)>{});
+        }
+      };
+
+      std::tuple<std::remove_reference_t<Ps>...> tup;
+      std::tuple<std::optional<typename Ps::value_type>...> partial_result;
+      cancellation_slot slot{this->cancel.slot()};
+    };
+
+    auto impl = std::allocate_shared<impl_t>(
+        get_associated_allocator(exec), exec, std::move(ps)...);
+    impl->executor = exec;
+
+    [impl, exec]<std::size_t... Idx>(std::index_sequence<Idx...>)
+    {
+      auto step =
+        [&]<std::size_t I>(std::integral_constant<std::size_t, I>)
+        {
+          return [impl]<typename... Args>(Args&& ... args)
+          {
+            std::get<I>(impl->partial_result).emplace(
+                std::forward<Args>(args)...);
+            if ((std::get<Idx>(impl->partial_result) && ...)) // we're done.
+            {
+              impl->result = {*std::get<Idx>(impl->partial_result)...};
+
+              impl->done = true;
+              if (auto f = std::exchange(impl->completion, nullptr); !!f)
+                std::apply(std::move(f), std::move(*impl->result));
+            }
+          };
+        };
+
+      (
+        std::get<Idx>(impl->tup).async_wait(
+          bind_executor(exec,
+            step(std::integral_constant<std::size_t, Idx>{}))),
+        ...
+      );
+    }(std::make_index_sequence<sizeof...(Ps)>{});
+
+    return {impl};
+  }
+
+  template <is_promise_c ... Ps>
+  static auto race(Ps  ... ps)
+  {
+    auto exec = get<0>(std::tie(ps...)).get_executor();
+    return race(std::move(exec), std::move(ps)...);
+  }
+
+  template <is_promise_c ... Ps>
+  static auto all(Ps ... ps)
+  {
+    auto exec = get<0>(std::tie(ps...)).get_executor();
+    return all(std::move(exec), std::move(ps)...);
+  }
+
+  template <execution::executor Executor1, typename Range>
+#if !defined(GENERATING_DOCUMENTATION)
+    requires requires (Range r)
+    {
+      {*std::begin(r)} -> is_promise_c;
+      {*std::  end(r)} -> is_promise_c;
+    }
+#endif // !defined(GENERATING_DOCUMENTATION)
+  static auto race(Executor1 exec, Range range)
+  {
+    using var_t = typename std::decay_t<
+        decltype(*std::begin(range))>::value_type;
+    using signature_type = std::conditional_t<
+        std::is_same_v<var_t, std::monostate>,
+        void(std::size_t),
+        void(std::size_t, var_t)>;
+    using pi = detail::promise_impl<signature_type, Executor1>;
+    using promise_t = promise<signature_type, Executor1>;
+
+    struct impl_t : pi
+    {
+      impl_t(Executor1 exec, Range&& range)
+        : pi(std::move(exec)),
+          range(std::move(range))
+      {
+        this->slot.template emplace<cancel_handler>(this);
+      }
+
+      struct cancel_handler
+      {
+        impl_t* self;
+
+        cancel_handler(impl_t* self)
+          : self(self)
+        {
+        }
+
+        void operator()(boost::asio::cancellation_type ct)
+        {
+          for (auto& r : self->range)
+            r.cancel(ct);
+        }
+      };
+
+      Range range;
+      cancellation_slot slot{this->cancel.slot()};
+    };
+
+    const auto size = std::distance(std::begin(range), std::end(range));
+    auto impl =  std::allocate_shared<impl_t>(
+        get_associated_allocator(exec), exec, std::move(range));
+    impl->executor = exec;
+
+    if (size == 0u)
+    {
+      if constexpr (std::is_same_v<var_t, std::monostate>)
+        impl->result = {-1};
+      else
+        impl->result = {-1, var_t{}};
+
+      impl->done = true;
+      if (auto f = std::exchange(impl->completion, nullptr); !!f)
+      {
+        boost::asio::post(exec,
+            [impl, f = std::move(f)]() mutable
+            {
+              std::apply(std::move(f), std::move(*impl->result));
+            });
+      }
+      return promise_t{impl};
+    }
+    auto idx = 0u;
+    for (auto& val : impl->range)
+    {
+      val.async_wait(
+          bind_executor(exec,
+            [idx, impl]<typename... Args>(Args&&... args)
+            {
+              if (impl->done)
+                return;
+              if constexpr (std::is_same_v<var_t, std::monostate>)
+                impl->result = idx;
+              else
+                impl->result = std::make_tuple(idx,
+                    var_t(std::forward<Args>(args)...));
+              impl->done = true;
+              if (auto f = std::exchange(impl->completion, nullptr); !!f)
+                std::apply(std::move(f), std::move(*impl->result));
+
+              auto jdx = 0u;
+
+              for (auto &tc : impl->range)
+                if (jdx++ != idx)
+                  tc.cancel();
+            }));
+      idx++;
+    }
+    return promise_t{impl};
+  }
+
+
+  template <execution::executor Executor1, typename Range>
+#if !defined(GENERATING_DOCUMENTATION)
+    requires requires (Range r)
+    {
+      {*std::begin(r)} -> is_promise_c;
+      {*std::  end(r)} -> is_promise_c;
+    }
+#endif // !defined(GENERATING_DOCUMENTATION)
+  static auto all(Executor1 exec, Range  range)
+    -> promise<
+        void(
+          std::vector<
+            typename std::decay_t<
+              decltype(*std::begin(range))
+            >::value_type
+          >
+        ), Executor1>
+  {
+    using var_t = typename std::decay_t<
+      decltype(*std::begin(range))>::value_type;
+    using pi = detail::promise_impl<void(std::vector<var_t>), Executor1>;
+
+    struct impl_t : pi
+    {
+      impl_t(Executor1 exec, Range&& range)
+        : pi(std::move(exec)),
+          range(std::move(range))
+      {
+        this->slot.template emplace<cancel_handler>(this);
+      }
+
+      struct cancel_handler
+      {
+        impl_t* self;
+
+        cancel_handler(impl_t* self)
+          : self(self)
+        {
+        }
+
+        void operator()(cancellation_type ct)
+        {
+          for (auto& r : self->range)
+            r.cancel(ct);
+        }
+      };
+
+      Range range;
+      std::vector<std::optional<var_t>> partial_result;
+      cancellation_slot slot{this->cancel.slot()};
+    };
+
+    const auto size = std::distance(std::begin(range), std::end(range));
+    auto impl =  std::allocate_shared<impl_t>(
+        get_associated_allocator(exec), exec, std::move(range));
+    impl->executor = exec;
+    impl->partial_result.resize(size);
+
+    if (size == 0u)
+    {
+      impl->result.emplace();
+      impl->done = true;
+      if (auto f = std::exchange(impl->completion, nullptr); !!f)
+        boost::asio::post(exec, [impl, f = std::move(f)]() mutable
+            {
+              std::apply(std::move(f), std::move(*impl->result));
+            });
+      return {impl};
+    }
+    auto idx = 0u;
+    for (auto& val : impl->range) {
+      val.async_wait(bind_executor(
+          exec,
+          [idx, impl]<typename... Args>(Args&&... args) {
+
+            impl->partial_result[idx].emplace(std::forward<Args>(args)...);
+            if (std::all_of(impl->partial_result.begin(),
+                  impl->partial_result.end(),
+                  [](auto &opt) {return opt.has_value();}))
+            {
+              impl->result.emplace();
+              get<0>(*impl->result).reserve(impl->partial_result.size());
+              for (auto& p : impl->partial_result)
+                get<0>(*impl->result).push_back(std::move(*p));
+
+              impl->done = true;
+              if (auto f = std::exchange(impl->completion, nullptr); !!f)
+                std::apply(std::move(f), std::move(*impl->result));
+            }
+
+          }));
+      idx++;
+    }
+    return {impl};
+  }
+
+  template <typename Range>
+#if !defined(GENERATING_DOCUMENTATION)
+    requires requires (Range r)
+    {
+      {*std::begin(r)} -> is_promise_c;
+      {*std::  end(r)} -> is_promise_c;
+    }
+#endif // !defined(GENERATING_DOCUMENTATION)
+  static auto race(Range range)
+  {
+    if (std::begin(range) == std::end(range))
+      throw std::logic_error(
+          "Can't use race on an empty range with deduced executor");
+    else
+      return race(std::begin(range)->get_executor(), std::move(range));
+  }
+
+  template <typename Range>
+#if !defined(GENERATING_DOCUMENTATION)
+    requires requires (Range&& r)
+    {
+      {*std::begin(r)} -> is_promise_c;
+      {*std::  end(r)} -> is_promise_c;
+    }
+#endif // !defined(GENERATING_DOCUMENTATION)
+  static auto all(Range range)
+  {
+    if (std::begin(range) == std::end(range))
+      throw std::logic_error(
+          "Can't use all on an empty range with deduced executor");
+    else
+      return all(std::begin(range)->get_executor(), std::move(range));
+  }
+
+private:
+#if !defined(GENERATING_DOCUMENTATION)
+  template <typename, typename> friend struct promise;
+  friend struct detail::promise_handler<void(Ts...)>;
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+  std::shared_ptr<detail::promise_impl<void(Ts...), Executor>> impl_;
+  promise(std::shared_ptr<detail::promise_impl<void(Ts...), Executor>> impl)
+    : impl_(impl)
+  {
+  }
+
+  struct initiate_async_wait
+  {
+    std::shared_ptr<detail::promise_impl<void(Ts...), Executor>> self_;
+
+    template <typename WaitHandler>
+    void operator()(WaitHandler&& handler) const
+    {
+      const auto exec = get_associated_executor(handler, self_->executor);
+      auto cancel = get_associated_cancellation_slot(handler);
+      if (self_->done)
+      {
+        boost::asio::post(exec,
+            [self = self_, h = std::forward<WaitHandler>(handler)]() mutable
+            {
+              std::apply(std::forward<WaitHandler>(h),
+                  std::move(*self->result));
+            });
+      }
+      else
+      {
+        if (cancel.is_connected())
+        {
+          struct cancel_handler
+          {
+            std::weak_ptr<detail::promise_impl<void(Ts...), Executor>> self;
+
+            cancel_handler(
+                std::weak_ptr<detail::promise_impl<void(Ts...), Executor>> self)
+              : self(std::move(self))
+            {
+            }
+
+            void operator()(cancellation_type level) const
+            {
+              if (auto p = self.lock(); p != nullptr)
+                p->cancel.emit(level);
+
+            }
+          };
+
+          cancel.template emplace<cancel_handler>(self_);
+        }
+
+        self_->completion = {exec, std::forward<WaitHandler>(handler)};
+      }
+    }
+  };
+};
+
+} // namespace experimental
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename Executor, typename R, typename... Args>
+struct async_result<experimental::use_promise_t<Executor>, R(Args...)>
+{
+  using handler_type = experimental::detail::promise_handler<
+    void(typename decay<Args>::type...), Executor>;
+
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate(Initiation initiation,
+      experimental::use_promise_t<Executor>, InitArgs... args)
+    -> typename handler_type::promise_type
+  {
+    handler_type ht{get_associated_executor(initiation)};
+    std::move(initiation)(ht, std::move(args)...);
+    return ht.make_promise();
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_PROMISE_HPP
diff --git a/boost/asio/experimental/use_coro.hpp b/boost/asio/experimental/use_coro.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..da953bd2296f0472f9fc935015516e7e1b94c8c4
--- /dev/null
+++ b/boost/asio/experimental/use_coro.hpp
@@ -0,0 +1,171 @@
+//
+// experimental/use_coro.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_USE_CORO_HPP
+#define BOOST_ASIO_EXPERIMENTAL_USE_CORO_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <optional>
+#include <boost/asio/bind_cancellation_slot.hpp>
+#include <boost/asio/bind_executor.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/asio/experimental/detail/partial_promise.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+class any_io_executor;
+
+namespace experimental {
+
+/// A completion token that represents the currently executing resumable
+/// coroutine.
+/**
+ * The @c use_coro_t class, with its value @c use_coro, is used to represent an
+ * operation that can be awaited by the current resumable coroutine. This
+ * completion token may be passed as a handler to an asynchronous operation.
+ * For example:
+ *
+ * @code coro<void> my_coroutine(tcp::socket my_socket)
+ * {
+ *   std::size_t n = co_await my_socket.async_read_some(buffer, use_coro);
+ *   ...
+ * } @endcode
+ *
+ * When used with co_await, the initiating function (@c async_read_some in the
+ * above example) suspends the current coroutine. The coroutine is resumed when
+ * the asynchronous operation completes, and the result of the operation is
+ * returned.
+ */
+template <typename Executor = any_io_executor>
+struct use_coro_t
+{
+  /// Default constructor.
+  BOOST_ASIO_CONSTEXPR use_coro_t(
+#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+# if defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
+      boost::asio::detail::source_location location =
+        boost::asio::detail::source_location::current()
+# endif // defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
+#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+    )
+#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+# if defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
+    : file_name_(location.file_name()),
+      line_(location.line()),
+      function_name_(location.function_name())
+# else // defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
+    : file_name_(0),
+      line_(0),
+      function_name_(0)
+# endif // defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
+#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+  {
+  }
+
+  /// Constructor used to specify file name, line, and function name.
+  BOOST_ASIO_CONSTEXPR use_coro_t(const char* file_name,
+      int line, const char* function_name)
+#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+    : file_name_(file_name),
+      line_(line),
+      function_name_(function_name)
+#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+  {
+#if !defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+    (void)file_name;
+    (void)line;
+    (void)function_name;
+#endif // !defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+  }
+
+  /// Adapts an executor to add the @c use_coro_t completion token as the
+  /// default.
+  template <typename InnerExecutor>
+  struct executor_with_default : InnerExecutor
+  {
+    /// Specify @c use_coro_t as the default completion token type.
+    typedef use_coro_t default_completion_token_type;
+
+    /// Construct the adapted executor from the inner executor type.
+    template <typename InnerExecutor1>
+    executor_with_default(const InnerExecutor1& ex,
+        typename constraint<
+          conditional<
+            !is_same<InnerExecutor1, executor_with_default>::value,
+            is_convertible<InnerExecutor1, InnerExecutor>,
+            false_type
+          >::type::value
+        >::type = 0) BOOST_ASIO_NOEXCEPT
+      : InnerExecutor(ex)
+    {
+    }
+  };
+
+  /// Type alias to adapt an I/O object to use @c use_coro_t as its
+  /// default completion token type.
+#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES) \
+  || defined(GENERATING_DOCUMENTATION)
+  template <typename T>
+  using as_default_on_t = typename T::template rebind_executor<
+      executor_with_default<typename T::executor_type> >::other;
+#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+  /// Function helper to adapt an I/O object to use @c use_coro_t as its
+  /// default completion token type.
+  template <typename T>
+  static typename decay<T>::type::template rebind_executor<
+      executor_with_default<typename decay<T>::type::executor_type>
+    >::other
+  as_default_on(BOOST_ASIO_MOVE_ARG(T) object)
+  {
+    return typename decay<T>::type::template rebind_executor<
+        executor_with_default<typename decay<T>::type::executor_type>
+      >::other(BOOST_ASIO_MOVE_CAST(T)(object));
+  }
+
+#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+  const char* file_name_;
+  int line_;
+  const char* function_name_;
+#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+};
+
+/// A completion token object that represents the currently executing resumable
+/// coroutine.
+/**
+ * See the documentation for boost::asio::use_coro_t for a usage example.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+constexpr use_coro_t<> use_coro;
+#elif defined(BOOST_ASIO_HAS_CONSTEXPR)
+constexpr use_coro_t<> use_coro(0, 0, 0);
+#elif defined(BOOST_ASIO_MSVC)
+__declspec(selectany) use_coro_t<> use_coro(0, 0, 0);
+#endif
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/experimental/impl/use_coro.hpp>
+#include <boost/asio/experimental/coro.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_USE_CORO_HPP
diff --git a/boost/asio/file_base.hpp b/boost/asio/file_base.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..2b97068d3eebb605aa12c528cf3c926f8bc0c7f3
--- /dev/null
+++ b/boost/asio/file_base.hpp
@@ -0,0 +1,168 @@
+//
+// file_base.hpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_FILE_BASE_HPP
+#define BOOST_ASIO_FILE_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_FILE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#if !defined(BOOST_ASIO_WINDOWS)
+# include <fcntl.h>
+#endif // !defined(BOOST_ASIO_WINDOWS)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// The file_base class is used as a base for the basic_stream_file and
+/// basic_random_access_file class templates so that we have a common place to
+/// define flags.
+class file_base
+{
+public:
+#if defined(GENERATING_DOCUMENTATION)
+  /// A bitmask type (C++ Std [lib.bitmask.types]).
+  typedef unspecified flags;
+
+  /// Open the file for reading.
+  static const flags read_only = implementation_defined;
+
+  /// Open the file for writing.
+  static const flags write_only = implementation_defined;
+
+  /// Open the file for reading and writing.
+  static const flags read_write = implementation_defined;
+
+  /// Open the file in append mode.
+  static const flags append = implementation_defined;
+
+  /// Create the file if it does not exist.
+  static const flags create = implementation_defined;
+
+  /// Ensure a new file is created. Must be combined with @c create.
+  static const flags exclusive = implementation_defined;
+
+  /// Open the file with any existing contents truncated.
+  static const flags truncate = implementation_defined;
+
+  /// Open the file so that write operations automatically synchronise the file
+  /// data and metadata to disk.
+  static const flags sync_all_on_write = implementation_defined;
+#else
+  enum flags
+  {
+#if defined(BOOST_ASIO_WINDOWS)
+    read_only = 1,
+    write_only = 2,
+    read_write = 4,
+    append = 8,
+    create = 16,
+    exclusive = 32,
+    truncate = 64,
+    sync_all_on_write = 128
+#else // defined(BOOST_ASIO_WINDOWS)
+    read_only = O_RDONLY,
+    write_only = O_WRONLY,
+    read_write = O_RDWR,
+    append = O_APPEND,
+    create = O_CREAT,
+    exclusive = O_EXCL,
+    truncate = O_TRUNC,
+    sync_all_on_write = O_SYNC
+#endif // defined(BOOST_ASIO_WINDOWS)
+  };
+
+  // Implement bitmask operations as shown in C++ Std [lib.bitmask.types].
+
+  friend flags operator&(flags x, flags y)
+  {
+    return static_cast<flags>(
+        static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
+  }
+
+  friend flags operator|(flags x, flags y)
+  {
+    return static_cast<flags>(
+        static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
+  }
+
+  friend flags operator^(flags x, flags y)
+  {
+    return static_cast<flags>(
+        static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
+  }
+
+  friend flags operator~(flags x)
+  {
+    return static_cast<flags>(~static_cast<unsigned int>(x));
+  }
+
+  friend flags& operator&=(flags& x, flags y)
+  {
+    x = x & y;
+    return x;
+  }
+
+  friend flags& operator|=(flags& x, flags y)
+  {
+    x = x | y;
+    return x;
+  }
+
+  friend flags& operator^=(flags& x, flags y)
+  {
+    x = x ^ y;
+    return x;
+  }
+#endif
+
+  /// Basis for seeking in a file.
+  enum seek_basis
+  {
+#if defined(GENERATING_DOCUMENTATION)
+    /// Seek to an absolute position.
+    seek_set = implementation_defined,
+
+    /// Seek to an offset relative to the current file position.
+    seek_cur = implementation_defined,
+
+    /// Seek to an offset relative to the end of the file.
+    seek_end = implementation_defined
+#else
+    seek_set = SEEK_SET,
+    seek_cur = SEEK_CUR,
+    seek_end = SEEK_END
+#endif
+  };
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  ~file_base()
+  {
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_FILE_BASE_HPP
diff --git a/boost/asio/generic/basic_endpoint.hpp b/boost/asio/generic/basic_endpoint.hpp
index e79f9a6b884182eec238e0011b4dd4e02c210598..c3586e6b9ff901c063c588fee5bb3faec313a39e 100644
--- a/boost/asio/generic/basic_endpoint.hpp
+++ b/boost/asio/generic/basic_endpoint.hpp
@@ -2,7 +2,7 @@
 // generic/basic_endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/generic/datagram_protocol.hpp b/boost/asio/generic/datagram_protocol.hpp
index bb0b0a4d73cc7c7cd78ad6ffa6460b631397993a..209713c04996a77d97896290c9ca50fc8411dd53 100644
--- a/boost/asio/generic/datagram_protocol.hpp
+++ b/boost/asio/generic/datagram_protocol.hpp
@@ -2,7 +2,7 @@
 // generic/datagram_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/generic/detail/endpoint.hpp b/boost/asio/generic/detail/endpoint.hpp
index 893c93fb49dbb7a8fa2d5c7d1523c1e3f358066d..8008145cfa5439bc956eff922c31d7b5cdaba842 100644
--- a/boost/asio/generic/detail/endpoint.hpp
+++ b/boost/asio/generic/detail/endpoint.hpp
@@ -2,7 +2,7 @@
 // generic/detail/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/generic/detail/impl/endpoint.ipp b/boost/asio/generic/detail/impl/endpoint.ipp
index e518304f7d369e848ae36caee2fc8f7f58769103..ba63dc7f9923c81c3a533be160a8fbd674e940e0 100644
--- a/boost/asio/generic/detail/impl/endpoint.ipp
+++ b/boost/asio/generic/detail/impl/endpoint.ipp
@@ -2,7 +2,7 @@
 // generic/detail/impl/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/generic/raw_protocol.hpp b/boost/asio/generic/raw_protocol.hpp
index e5759f00538cd3eb48327ba9ce3aaec9b7af63b1..8332539b01b9208dcf4e81f7e09a692ba49dfa28 100644
--- a/boost/asio/generic/raw_protocol.hpp
+++ b/boost/asio/generic/raw_protocol.hpp
@@ -2,7 +2,7 @@
 // generic/raw_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/generic/seq_packet_protocol.hpp b/boost/asio/generic/seq_packet_protocol.hpp
index 54106e92e332c9a99b86a2b8e3911251aaa9fcb5..edab62d8485709beeb0e1df5edf148a07dbf456f 100644
--- a/boost/asio/generic/seq_packet_protocol.hpp
+++ b/boost/asio/generic/seq_packet_protocol.hpp
@@ -2,7 +2,7 @@
 // generic/seq_packet_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/generic/stream_protocol.hpp b/boost/asio/generic/stream_protocol.hpp
index 0c3eb8eb5f1304fd0fd7a6c4dd4c3834f143a693..2ee8bb029e5beae5a3dd50cd9cfaf8b318305072 100644
--- a/boost/asio/generic/stream_protocol.hpp
+++ b/boost/asio/generic/stream_protocol.hpp
@@ -2,7 +2,7 @@
 // generic/stream_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/handler_alloc_hook.hpp b/boost/asio/handler_alloc_hook.hpp
index b311e431324f6ccf5b25324b0c721cffc2fa2e74..7b8d89bac7848f2da8f85adb8e3bbfbdb25d1b93 100644
--- a/boost/asio/handler_alloc_hook.hpp
+++ b/boost/asio/handler_alloc_hook.hpp
@@ -2,7 +2,7 @@
 // handler_alloc_hook.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/handler_continuation_hook.hpp b/boost/asio/handler_continuation_hook.hpp
index 02ff4d718e061a1e8416835efee29dfd3c646f5d..ba3c4122ce30f6314af268eee8baa17f08ae50af 100644
--- a/boost/asio/handler_continuation_hook.hpp
+++ b/boost/asio/handler_continuation_hook.hpp
@@ -2,7 +2,7 @@
 // handler_continuation_hook.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/handler_invoke_hook.hpp b/boost/asio/handler_invoke_hook.hpp
index 92a1b4250ce9ab2199d9af2e1758a4fce0d09063..a9fbc86293cdf4420d8855daa4bab1845d523eec 100644
--- a/boost/asio/handler_invoke_hook.hpp
+++ b/boost/asio/handler_invoke_hook.hpp
@@ -2,7 +2,7 @@
 // handler_invoke_hook.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/high_resolution_timer.hpp b/boost/asio/high_resolution_timer.hpp
index ff221a919e1aac8eeb762d51790c36b37466aa61..8c7633ae7d530bbd65183ee6b24f6ab9586b07af 100644
--- a/boost/asio/high_resolution_timer.hpp
+++ b/boost/asio/high_resolution_timer.hpp
@@ -2,7 +2,7 @@
 // high_resolution_timer.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/any_io_executor.ipp b/boost/asio/impl/any_io_executor.ipp
new file mode 100644
index 0000000000000000000000000000000000000000..c7dc91972b584eb87fc7d1c920b0283a2708cf4b
--- /dev/null
+++ b/boost/asio/impl/any_io_executor.ipp
@@ -0,0 +1,131 @@
+//
+// impl/any_io_executor.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IMPL_ANY_IO_EXECUTOR_IPP
+#define BOOST_ASIO_IMPL_ANY_IO_EXECUTOR_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if !defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+#include <boost/asio/any_io_executor.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+any_io_executor::any_io_executor() BOOST_ASIO_NOEXCEPT
+  : base_type()
+{
+}
+
+any_io_executor::any_io_executor(nullptr_t) BOOST_ASIO_NOEXCEPT
+  : base_type(nullptr_t())
+{
+}
+
+any_io_executor::any_io_executor(const any_io_executor& e) BOOST_ASIO_NOEXCEPT
+  : base_type(static_cast<const base_type&>(e))
+{
+}
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+any_io_executor::any_io_executor(any_io_executor&& e) BOOST_ASIO_NOEXCEPT
+  : base_type(static_cast<base_type&&>(e))
+{
+}
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+any_io_executor& any_io_executor::operator=(
+    const any_io_executor& e) BOOST_ASIO_NOEXCEPT
+{
+  base_type::operator=(static_cast<const base_type&>(e));
+  return *this;
+}
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+any_io_executor& any_io_executor::operator=(
+    any_io_executor&& e) BOOST_ASIO_NOEXCEPT
+{
+  base_type::operator=(static_cast<base_type&&>(e));
+  return *this;
+}
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+any_io_executor& any_io_executor::operator=(nullptr_t)
+{
+  base_type::operator=(nullptr_t());
+  return *this;
+}
+
+any_io_executor::~any_io_executor()
+{
+}
+
+void any_io_executor::swap(any_io_executor& other) BOOST_ASIO_NOEXCEPT
+{
+  static_cast<base_type&>(*this).swap(static_cast<base_type&>(other));
+}
+
+template <>
+any_io_executor any_io_executor::require(
+    const execution::blocking_t::never_t& p, int) const
+{
+  return static_cast<const base_type&>(*this).require(p);
+}
+
+template <>
+any_io_executor any_io_executor::prefer(
+    const execution::blocking_t::possibly_t& p, int) const
+{
+  return static_cast<const base_type&>(*this).prefer(p);
+}
+
+template <>
+any_io_executor any_io_executor::prefer(
+    const execution::outstanding_work_t::tracked_t& p, int) const
+{
+  return static_cast<const base_type&>(*this).prefer(p);
+}
+
+template <>
+any_io_executor any_io_executor::prefer(
+    const execution::outstanding_work_t::untracked_t& p, int) const
+{
+  return static_cast<const base_type&>(*this).prefer(p);
+}
+
+template <>
+any_io_executor any_io_executor::prefer(
+    const execution::relationship_t::fork_t& p, int) const
+{
+  return static_cast<const base_type&>(*this).prefer(p);
+}
+
+template <>
+any_io_executor any_io_executor::prefer(
+    const execution::relationship_t::continuation_t& p, int) const
+{
+  return static_cast<const base_type&>(*this).prefer(p);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // !defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+#endif // BOOST_ASIO_IMPL_ANY_IO_EXECUTOR_IPP
diff --git a/boost/asio/impl/awaitable.hpp b/boost/asio/impl/awaitable.hpp
index eeb8f240567c6a7d0cd987c813543e6df0502e03..c66fa74c6073144e5b72c7546cae946045ca5c8f 100644
--- a/boost/asio/impl/awaitable.hpp
+++ b/boost/asio/impl/awaitable.hpp
@@ -2,7 +2,7 @@
 // impl/awaitable.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,10 +19,13 @@
 #include <exception>
 #include <new>
 #include <tuple>
-#include <utility>
+#include <boost/asio/cancellation_signal.hpp>
+#include <boost/asio/cancellation_state.hpp>
 #include <boost/asio/detail/thread_context.hpp>
 #include <boost/asio/detail/thread_info_base.hpp>
+#include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/error.hpp>
 #include <boost/asio/post.hpp>
 #include <boost/system/system_error.hpp>
 #include <boost/asio/this_coro.hpp>
@@ -33,6 +36,8 @@ namespace boost {
 namespace asio {
 namespace detail {
 
+struct awaitable_thread_has_context_switched {};
+
 // An awaitable_thread represents a thread-of-execution that is composed of one
 // or more "stack frames", with each frame represented by an awaitable_frame.
 // All execution occurs in the context of the awaitable_thread's executor. An
@@ -147,9 +152,17 @@ public:
     }
   }
 
+  void clear_cancellation_slot()
+  {
+    this->attached_thread_->entry_point()->cancellation_state_.slot().clear();
+  }
+
   template <typename T>
   auto await_transform(awaitable<T, Executor> a) const
   {
+    if (attached_thread_->entry_point()->throw_if_cancelled_)
+      if (!!attached_thread_->get_cancellation_state().cancelled())
+        do_throw_error(boost::asio::error::operation_aborted, "co_await");
     return a;
   }
 
@@ -179,6 +192,175 @@ public:
     return result{this};
   }
 
+  // This await transformation obtains the associated cancellation state of the
+  // thread of execution.
+  auto await_transform(this_coro::cancellation_state_t) noexcept
+  {
+    struct result
+    {
+      awaitable_frame_base* this_;
+
+      bool await_ready() const noexcept
+      {
+        return true;
+      }
+
+      void await_suspend(coroutine_handle<void>) noexcept
+      {
+      }
+
+      auto await_resume() const noexcept
+      {
+        return this_->attached_thread_->get_cancellation_state();
+      }
+    };
+
+    return result{this};
+  }
+
+  // This await transformation resets the associated cancellation state.
+  auto await_transform(this_coro::reset_cancellation_state_0_t) noexcept
+  {
+    struct result
+    {
+      awaitable_frame_base* this_;
+
+      bool await_ready() const noexcept
+      {
+        return true;
+      }
+
+      void await_suspend(coroutine_handle<void>) noexcept
+      {
+      }
+
+      auto await_resume() const
+      {
+        return this_->attached_thread_->reset_cancellation_state();
+      }
+    };
+
+    return result{this};
+  }
+
+  // This await transformation resets the associated cancellation state.
+  template <typename Filter>
+  auto await_transform(
+      this_coro::reset_cancellation_state_1_t<Filter> reset) noexcept
+  {
+    struct result
+    {
+      awaitable_frame_base* this_;
+      Filter filter_;
+
+      bool await_ready() const noexcept
+      {
+        return true;
+      }
+
+      void await_suspend(coroutine_handle<void>) noexcept
+      {
+      }
+
+      auto await_resume()
+      {
+        return this_->attached_thread_->reset_cancellation_state(
+            BOOST_ASIO_MOVE_CAST(Filter)(filter_));
+      }
+    };
+
+    return result{this, BOOST_ASIO_MOVE_CAST(Filter)(reset.filter)};
+  }
+
+  // This await transformation resets the associated cancellation state.
+  template <typename InFilter, typename OutFilter>
+  auto await_transform(
+      this_coro::reset_cancellation_state_2_t<InFilter, OutFilter> reset)
+    noexcept
+  {
+    struct result
+    {
+      awaitable_frame_base* this_;
+      InFilter in_filter_;
+      OutFilter out_filter_;
+
+      bool await_ready() const noexcept
+      {
+        return true;
+      }
+
+      void await_suspend(coroutine_handle<void>) noexcept
+      {
+      }
+
+      auto await_resume()
+      {
+        return this_->attached_thread_->reset_cancellation_state(
+            BOOST_ASIO_MOVE_CAST(InFilter)(in_filter_),
+            BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter_));
+      }
+    };
+
+    return result{this,
+        BOOST_ASIO_MOVE_CAST(InFilter)(reset.in_filter),
+        BOOST_ASIO_MOVE_CAST(OutFilter)(reset.out_filter)};
+  }
+
+  // This await transformation determines whether cancellation is propagated as
+  // an exception.
+  auto await_transform(this_coro::throw_if_cancelled_0_t)
+    noexcept
+  {
+    struct result
+    {
+      awaitable_frame_base* this_;
+
+      bool await_ready() const noexcept
+      {
+        return true;
+      }
+
+      void await_suspend(coroutine_handle<void>) noexcept
+      {
+      }
+
+      auto await_resume()
+      {
+        return this_->attached_thread_->throw_if_cancelled();
+      }
+    };
+
+    return result{this};
+  }
+
+  // This await transformation sets whether cancellation is propagated as an
+  // exception.
+  auto await_transform(this_coro::throw_if_cancelled_1_t throw_if_cancelled)
+    noexcept
+  {
+    struct result
+    {
+      awaitable_frame_base* this_;
+      bool value_;
+
+      bool await_ready() const noexcept
+      {
+        return true;
+      }
+
+      void await_suspend(coroutine_handle<void>) noexcept
+      {
+      }
+
+      auto await_resume()
+      {
+        this_->attached_thread_->throw_if_cancelled(value_);
+      }
+    };
+
+    return result{this, throw_if_cancelled.value};
+  }
+
   // This await transformation is used to run an async operation's initiation
   // function object after the coroutine has been suspended. This ensures that
   // immediate resumption of the coroutine in another thread does not cause a
@@ -190,7 +372,7 @@ public:
           typename result_of<Function(awaitable_frame_base*)>::type,
           awaitable_thread<Executor>*
         >::value
-      >::type* = 0)
+      >::type* = nullptr)
   {
     struct result
     {
@@ -215,6 +397,31 @@ public:
     return result{std::move(f), this};
   }
 
+  // Access the awaitable thread's has_context_switched_ flag.
+  auto await_transform(detail::awaitable_thread_has_context_switched) noexcept
+  {
+    struct result
+    {
+      awaitable_frame_base* this_;
+
+      bool await_ready() const noexcept
+      {
+        return true;
+      }
+
+      void await_suspend(coroutine_handle<void>) noexcept
+      {
+      }
+
+      bool& await_resume() const noexcept
+      {
+        return this_->attached_thread_->entry_point()->has_context_switched_;
+      }
+    };
+
+    return result{this};
+  }
+
   void attach_thread(awaitable_thread<Executor>* handler) noexcept
   {
     attached_thread_ = handler;
@@ -222,6 +429,7 @@ public:
 
   awaitable_thread<Executor>* detach_thread() noexcept
   {
+    attached_thread_->entry_point()->has_context_switched_ = true;
     return std::exchange(attached_thread_, nullptr);
   }
 
@@ -229,7 +437,7 @@ public:
   {
     caller_ = caller;
     attached_thread_ = caller_->attached_thread_;
-    attached_thread_->top_of_stack_ = this;
+    attached_thread_->entry_point()->top_of_stack_ = this;
     caller_->attached_thread_ = nullptr;
   }
 
@@ -237,7 +445,7 @@ public:
   {
     if (caller_)
       caller_->attached_thread_ = attached_thread_;
-    attached_thread_->top_of_stack_ = caller_;
+    attached_thread_->entry_point()->top_of_stack_ = caller_;
     attached_thread_ = nullptr;
     caller_ = nullptr;
   }
@@ -332,25 +540,87 @@ public:
   }
 };
 
+struct awaitable_thread_entry_point {};
+
+template <typename Executor>
+class awaitable_frame<awaitable_thread_entry_point, Executor>
+  : public awaitable_frame_base<Executor>
+{
+public:
+  awaitable_frame()
+    : top_of_stack_(0),
+      has_executor_(false),
+      has_context_switched_(false),
+      throw_if_cancelled_(true)
+  {
+  }
+
+  ~awaitable_frame()
+  {
+    if (has_executor_)
+      u_.executor_.~Executor();
+  }
+
+  awaitable<awaitable_thread_entry_point, Executor> get_return_object()
+  {
+    this->coro_ = coroutine_handle<awaitable_frame>::from_promise(*this);
+    return awaitable<awaitable_thread_entry_point, Executor>(this);
+  };
+
+  void return_void()
+  {
+  }
+
+  void get()
+  {
+    this->caller_ = nullptr;
+    this->rethrow_exception();
+  }
+
+private:
+  template <typename> friend class awaitable_frame_base;
+  template <typename, typename> friend class awaitable_handler_base;
+  template <typename> friend class awaitable_thread;
+
+  union u
+  {
+    u() {}
+    ~u() {}
+    char c_;
+    Executor executor_;
+  } u_;
+
+  awaitable_frame_base<Executor>* top_of_stack_;
+  boost::asio::cancellation_slot parent_cancellation_slot_;
+  boost::asio::cancellation_state cancellation_state_;
+  bool has_executor_;
+  bool has_context_switched_;
+  bool throw_if_cancelled_;
+};
+
 template <typename Executor>
 class awaitable_thread
 {
 public:
   typedef Executor executor_type;
+  typedef cancellation_slot cancellation_slot_type;
 
   // Construct from the entry point of a new thread of execution.
-  awaitable_thread(awaitable<void, Executor> p, const Executor& ex)
-    : bottom_of_stack_(std::move(p)),
-      top_of_stack_(bottom_of_stack_.frame_),
-      executor_(ex)
-  {
+  awaitable_thread(awaitable<awaitable_thread_entry_point, Executor> p,
+      const Executor& ex, cancellation_slot parent_cancel_slot,
+      cancellation_state cancel_state)
+    : bottom_of_stack_(std::move(p))
+  {
+    bottom_of_stack_.frame_->top_of_stack_ = bottom_of_stack_.frame_;
+    new (&bottom_of_stack_.frame_->u_.executor_) Executor(ex);
+    bottom_of_stack_.frame_->has_executor_ = true;
+    bottom_of_stack_.frame_->parent_cancellation_slot_ = parent_cancel_slot;
+    bottom_of_stack_.frame_->cancellation_state_ = cancel_state;
   }
 
   // Transfer ownership from another awaitable_thread.
   awaitable_thread(awaitable_thread&& other) noexcept
-    : bottom_of_stack_(std::move(other.bottom_of_stack_)),
-      top_of_stack_(std::exchange(other.top_of_stack_, nullptr)),
-      executor_(std::move(other.executor_))
+    : bottom_of_stack_(std::move(other.bottom_of_stack_))
   {
   }
 
@@ -361,23 +631,74 @@ public:
     if (bottom_of_stack_.valid())
     {
       // Coroutine "stack unwinding" must be performed through the executor.
-      (post)(executor_,
+      auto* bottom_frame = bottom_of_stack_.frame_;
+      (post)(bottom_frame->u_.executor_,
           [a = std::move(bottom_of_stack_)]() mutable
           {
-            awaitable<void, Executor>(std::move(a));
+            (void)awaitable<awaitable_thread_entry_point, Executor>(
+                std::move(a));
           });
     }
   }
 
+  awaitable_frame<awaitable_thread_entry_point, Executor>* entry_point()
+  {
+    return bottom_of_stack_.frame_;
+  }
+
   executor_type get_executor() const noexcept
   {
-    return executor_;
+    return bottom_of_stack_.frame_->u_.executor_;
+  }
+
+  cancellation_state get_cancellation_state() const noexcept
+  {
+    return bottom_of_stack_.frame_->cancellation_state_;
+  }
+
+  void reset_cancellation_state()
+  {
+    bottom_of_stack_.frame_->cancellation_state_ =
+      cancellation_state(bottom_of_stack_.frame_->parent_cancellation_slot_);
+  }
+
+  template <typename Filter>
+  void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(Filter) filter)
+  {
+    bottom_of_stack_.frame_->cancellation_state_ =
+      cancellation_state(bottom_of_stack_.frame_->parent_cancellation_slot_,
+        BOOST_ASIO_MOVE_CAST(Filter)(filter));
+  }
+
+  template <typename InFilter, typename OutFilter>
+  void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
+      BOOST_ASIO_MOVE_ARG(OutFilter) out_filter)
+  {
+    bottom_of_stack_.frame_->cancellation_state_ =
+      cancellation_state(bottom_of_stack_.frame_->parent_cancellation_slot_,
+        BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
+        BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter));
+  }
+
+  bool throw_if_cancelled() const
+  {
+    return bottom_of_stack_.frame_->throw_if_cancelled_;
+  }
+
+  void throw_if_cancelled(bool value)
+  {
+    bottom_of_stack_.frame_->throw_if_cancelled_ = value;
+  }
+
+  cancellation_slot_type get_cancellation_slot() const noexcept
+  {
+    return bottom_of_stack_.frame_->cancellation_state_.slot();
   }
 
   // Launch a new thread of execution.
   void launch()
   {
-    top_of_stack_->attach_thread(this);
+    bottom_of_stack_.frame_->top_of_stack_->attach_thread(this);
     pump();
   }
 
@@ -388,17 +709,19 @@ protected:
   // has been transferred to another resumable_thread object.
   void pump()
   {
-    do top_of_stack_->resume(); while (top_of_stack_);
-    if (bottom_of_stack_.valid())
+    do
+      bottom_of_stack_.frame_->top_of_stack_->resume();
+    while (bottom_of_stack_.frame_ && bottom_of_stack_.frame_->top_of_stack_);
+
+    if (bottom_of_stack_.frame_)
     {
-      awaitable<void, Executor> a(std::move(bottom_of_stack_));
+      awaitable<awaitable_thread_entry_point, Executor> a(
+          std::move(bottom_of_stack_));
       a.frame_->rethrow_exception();
     }
   }
 
-  awaitable<void, Executor> bottom_of_stack_;
-  awaitable_frame_base<Executor>* top_of_stack_;
-  executor_type executor_;
+  awaitable<awaitable_thread_entry_point, Executor> bottom_of_stack_;
 };
 
 } // namespace detail
diff --git a/boost/asio/impl/buffered_read_stream.hpp b/boost/asio/impl/buffered_read_stream.hpp
index 2a1362b5fcb8594715ce490d41d37c0ac12a3393..aceca05a9ee80213af41ebd944767348f8e01b36 100644
--- a/boost/asio/impl/buffered_read_stream.hpp
+++ b/boost/asio/impl/buffered_read_stream.hpp
@@ -2,7 +2,7 @@
 // impl/buffered_read_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,8 +15,7 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associator.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>
@@ -92,7 +91,7 @@ namespace detail
         const std::size_t bytes_transferred)
     {
       storage_.resize(previous_size_ + bytes_transferred);
-      handler_(ec, bytes_transferred);
+      BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(ec, bytes_transferred);
     }
 
   //private:
@@ -203,30 +202,18 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename ReadHandler, typename Allocator>
-struct associated_allocator<
-    detail::buffered_fill_handler<ReadHandler>, Allocator>
+template <template <typename, typename> class Associator,
+    typename ReadHandler, typename DefaultCandidate>
+struct associator<Associator,
+    detail::buffered_fill_handler<ReadHandler>,
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(const detail::buffered_fill_handler<ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename ReadHandler, typename Executor>
-struct associated_executor<
-    detail::buffered_fill_handler<ReadHandler>, Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
-{
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(const detail::buffered_fill_handler<ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
+      const detail::buffered_fill_handler<ReadHandler>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -314,14 +301,14 @@ namespace detail
       if (ec || storage_.empty())
       {
         const std::size_t length = 0;
-        handler_(ec, length);
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(ec, length);
       }
       else
       {
         const std::size_t bytes_copied = boost::asio::buffer_copy(
             buffers_, storage_.data(), storage_.size());
         storage_.consume(bytes_copied);
-        handler_(ec, bytes_copied);
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(ec, bytes_copied);
       }
     }
 
@@ -449,38 +436,20 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename MutableBufferSequence,
-    typename ReadHandler, typename Allocator>
-struct associated_allocator<
+template <template <typename, typename> class Associator,
+    typename MutableBufferSequence, typename ReadHandler,
+    typename DefaultCandidate>
+struct associator<Associator,
     detail::buffered_read_some_handler<MutableBufferSequence, ReadHandler>,
-    Allocator>
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(
-      const detail::buffered_read_some_handler<
-        MutableBufferSequence, ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename MutableBufferSequence,
-    typename ReadHandler, typename Executor>
-struct associated_executor<
-    detail::buffered_read_some_handler<MutableBufferSequence, ReadHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
-{
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::buffered_read_some_handler<
         MutableBufferSequence, ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
diff --git a/boost/asio/impl/buffered_write_stream.hpp b/boost/asio/impl/buffered_write_stream.hpp
index e900da196767b2ab8a6a065696ab9ff50824c699..2b9e88e16f320886bd2d117e06c0d679acb3e69b 100644
--- a/boost/asio/impl/buffered_write_stream.hpp
+++ b/boost/asio/impl/buffered_write_stream.hpp
@@ -2,7 +2,7 @@
 // impl/buffered_write_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,8 +15,7 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associator.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>
@@ -78,7 +77,7 @@ namespace detail
         const std::size_t bytes_written)
     {
       storage_.consume(bytes_written);
-      handler_(ec, bytes_written);
+      BOOST_ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(ec, bytes_written);
     }
 
   //private:
@@ -183,30 +182,18 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename WriteHandler, typename Allocator>
-struct associated_allocator<
-    detail::buffered_flush_handler<WriteHandler>, Allocator>
+template <template <typename, typename> class Associator,
+    typename WriteHandler, typename DefaultCandidate>
+struct associator<Associator,
+    detail::buffered_flush_handler<WriteHandler>,
+    DefaultCandidate>
+  : Associator<WriteHandler, DefaultCandidate>
 {
-  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
-
-  static type get(const detail::buffered_flush_handler<WriteHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename WriteHandler, typename Executor>
-struct associated_executor<
-    detail::buffered_flush_handler<WriteHandler>, Executor>
-  : detail::associated_executor_forwarding_base<WriteHandler, Executor>
-{
-  typedef typename associated_executor<WriteHandler, Executor>::type type;
-
-  static type get(const detail::buffered_flush_handler<WriteHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<WriteHandler, DefaultCandidate>::type get(
+      const detail::buffered_flush_handler<WriteHandler>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -294,7 +281,7 @@ namespace detail
       if (ec)
       {
         const std::size_t length = 0;
-        handler_(ec, length);
+        BOOST_ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(ec, length);
       }
       else
       {
@@ -307,7 +294,7 @@ namespace detail
         storage_.resize(orig_size + length);
         const std::size_t bytes_copied = boost::asio::buffer_copy(
             storage_.data() + orig_size, buffers_, length);
-        handler_(ec, bytes_copied);
+        BOOST_ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(ec, bytes_copied);
       }
     }
 
@@ -435,38 +422,20 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename ConstBufferSequence,
-    typename WriteHandler, typename Allocator>
-struct associated_allocator<
+template <template <typename, typename> class Associator,
+    typename ConstBufferSequence, typename WriteHandler,
+    typename DefaultCandidate>
+struct associator<Associator,
     detail::buffered_write_some_handler<ConstBufferSequence, WriteHandler>,
-    Allocator>
+    DefaultCandidate>
+  : Associator<WriteHandler, DefaultCandidate>
 {
-  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
-
-  static type get(
-      const detail::buffered_write_some_handler<
-        ConstBufferSequence, WriteHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename ConstBufferSequence,
-    typename WriteHandler, typename Executor>
-struct associated_executor<
-    detail::buffered_write_some_handler<ConstBufferSequence, WriteHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<WriteHandler, Executor>
-{
-  typedef typename associated_executor<WriteHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<WriteHandler, DefaultCandidate>::type get(
       const detail::buffered_write_some_handler<
         ConstBufferSequence, WriteHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
diff --git a/boost/asio/impl/cancellation_signal.ipp b/boost/asio/impl/cancellation_signal.ipp
new file mode 100644
index 0000000000000000000000000000000000000000..dad7c36245490fed7bdfdef673507891ec09cdc7
--- /dev/null
+++ b/boost/asio/impl/cancellation_signal.ipp
@@ -0,0 +1,98 @@
+//
+// impl/cancellation_signal.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IMPL_CANCELLATION_SIGNAL_IPP
+#define BOOST_ASIO_IMPL_CANCELLATION_SIGNAL_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/cancellation_signal.hpp>
+#include <boost/asio/detail/thread_context.hpp>
+#include <boost/asio/detail/thread_info_base.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+cancellation_signal::~cancellation_signal()
+{
+  if (handler_)
+  {
+    std::pair<void*, std::size_t> mem = handler_->destroy();
+    detail::thread_info_base::deallocate(
+        detail::thread_info_base::cancellation_signal_tag(),
+        detail::thread_context::top_of_thread_call_stack(),
+        mem.first, mem.second);
+  }
+}
+
+void cancellation_slot::clear()
+{
+  if (handler_ != 0 && *handler_ != 0)
+  {
+    std::pair<void*, std::size_t> mem = (*handler_)->destroy();
+    detail::thread_info_base::deallocate(
+        detail::thread_info_base::cancellation_signal_tag(),
+        detail::thread_context::top_of_thread_call_stack(),
+        mem.first, mem.second);
+    *handler_ = 0;
+  }
+}
+
+std::pair<void*, std::size_t> cancellation_slot::prepare_memory(
+    std::size_t size, std::size_t align)
+{
+  assert(handler_);
+  std::pair<void*, std::size_t> mem;
+  if (*handler_)
+  {
+    mem = (*handler_)->destroy();
+    *handler_ = 0;
+  }
+  if (size > mem.second
+      || reinterpret_cast<std::size_t>(mem.first) % align != 0)
+  {
+    if (mem.first)
+    {
+      detail::thread_info_base::deallocate(
+          detail::thread_info_base::cancellation_signal_tag(),
+          detail::thread_context::top_of_thread_call_stack(),
+          mem.first, mem.second);
+    }
+    mem.first = detail::thread_info_base::allocate(
+        detail::thread_info_base::cancellation_signal_tag(),
+        detail::thread_context::top_of_thread_call_stack(),
+        size, align);
+    mem.second = size;
+  }
+  return mem;
+}
+
+cancellation_slot::auto_delete_helper::~auto_delete_helper()
+{
+  if (mem.first)
+  {
+    detail::thread_info_base::deallocate(
+        detail::thread_info_base::cancellation_signal_tag(),
+        detail::thread_context::top_of_thread_call_stack(),
+        mem.first, mem.second);
+  }
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_CANCELLATION_SIGNAL_IPP
diff --git a/boost/asio/impl/co_spawn.hpp b/boost/asio/impl/co_spawn.hpp
index d678bdf5d1e0711d4a36666b1571b346721dacc0..46f65d781caba6e82512a3e366aa118852b96962 100644
--- a/boost/asio/impl/co_spawn.hpp
+++ b/boost/asio/impl/co_spawn.hpp
@@ -2,7 +2,7 @@
 // impl/co_spawn.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,6 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <boost/asio/associated_cancellation_slot.hpp>
 #include <boost/asio/awaitable.hpp>
 #include <boost/asio/dispatch.hpp>
 #include <boost/asio/execution/outstanding_work.hpp>
@@ -77,16 +78,18 @@ make_co_spawn_work_guard(const Executor& ex)
 }
 
 template <typename T, typename Executor, typename F, typename Handler>
-awaitable<void, Executor> co_spawn_entry_point(
+awaitable<awaitable_thread_entry_point, Executor> co_spawn_entry_point(
     awaitable<T, Executor>*, Executor ex, F f, Handler handler)
 {
   auto spawn_work = make_co_spawn_work_guard(ex);
   auto handler_work = make_co_spawn_work_guard(
       boost::asio::get_associated_executor(handler, ex));
 
-  (void) co_await (post)(spawn_work.get_executor(),
-      use_awaitable_t<Executor>{});
+  (void) co_await (dispatch)(
+      use_awaitable_t<Executor>{__FILE__, __LINE__, "co_spawn_entry_point"});
 
+  (co_await awaitable_thread_has_context_switched{}) = false;
+  std::exception_ptr e = nullptr;
   bool done = false;
   try
   {
@@ -94,36 +97,63 @@ awaitable<void, Executor> co_spawn_entry_point(
 
     done = true;
 
-    (dispatch)(handler_work.get_executor(),
-        [handler = std::move(handler), t = std::move(t)]() mutable
-        {
-          handler(std::exception_ptr(), std::move(t));
-        });
+    if (co_await awaitable_thread_has_context_switched{})
+    {
+      (dispatch)(handler_work.get_executor(),
+          [handler = std::move(handler), t = std::move(t)]() mutable
+          {
+            std::move(handler)(std::exception_ptr(), std::move(t));
+          });
+    }
+    else
+    {
+      (post)(handler_work.get_executor(),
+          [handler = std::move(handler), t = std::move(t)]() mutable
+          {
+            std::move(handler)(std::exception_ptr(), std::move(t));
+          });
+    }
+
+    co_return;
   }
   catch (...)
   {
     if (done)
       throw;
 
+    e = std::current_exception();
+  }
+
+  if (co_await awaitable_thread_has_context_switched{})
+  {
     (dispatch)(handler_work.get_executor(),
-        [handler = std::move(handler), e = std::current_exception()]() mutable
+        [handler = std::move(handler), e]() mutable
+        {
+          std::move(handler)(e, T());
+        });
+  }
+  else
+  {
+    (post)(handler_work.get_executor(),
+        [handler = std::move(handler), e]() mutable
         {
-          handler(e, T());
+          std::move(handler)(e, T());
         });
   }
 }
 
 template <typename Executor, typename F, typename Handler>
-awaitable<void, Executor> co_spawn_entry_point(
+awaitable<awaitable_thread_entry_point, Executor> co_spawn_entry_point(
     awaitable<void, Executor>*, Executor ex, F f, Handler handler)
 {
   auto spawn_work = make_co_spawn_work_guard(ex);
   auto handler_work = make_co_spawn_work_guard(
       boost::asio::get_associated_executor(handler, ex));
 
-  (void) co_await (post)(spawn_work.get_executor(),
+  (void) co_await (dispatch)(
       use_awaitable_t<Executor>{__FILE__, __LINE__, "co_spawn_entry_point"});
 
+  (co_await awaitable_thread_has_context_switched{}) = false;
   std::exception_ptr e = nullptr;
   try
   {
@@ -134,11 +164,22 @@ awaitable<void, Executor> co_spawn_entry_point(
     e = std::current_exception();
   }
 
-  (dispatch)(handler_work.get_executor(),
-      [handler = std::move(handler), e]() mutable
-      {
-        handler(e);
-      });
+  if (co_await awaitable_thread_has_context_switched{})
+  {
+    (dispatch)(handler_work.get_executor(),
+        [handler = std::move(handler), e]() mutable
+        {
+          std::move(handler)(e);
+        });
+  }
+  else
+  {
+    (post)(handler_work.get_executor(),
+        [handler = std::move(handler), e]() mutable
+        {
+          std::move(handler)(e);
+        });
+  }
 }
 
 template <typename T, typename Executor>
@@ -181,9 +222,16 @@ public:
   {
     typedef typename result_of<F()>::type awaitable_type;
 
+    cancellation_state proxy_cancel_state(
+        boost::asio::get_associated_cancellation_slot(handler),
+        enable_total_cancellation());
+
+    cancellation_state cancel_state(proxy_cancel_state.slot());
+
     auto a = (co_spawn_entry_point)(static_cast<awaitable_type*>(nullptr),
         ex_, std::forward<F>(f), std::forward<Handler>(handler));
-    awaitable_handler<executor_type, void>(std::move(a), ex_).launch();
+    awaitable_handler<executor_type, void>(std::move(a), ex_,
+        proxy_cancel_state.slot(), cancel_state).launch();
   }
 
 private:
diff --git a/boost/asio/impl/compose.hpp b/boost/asio/impl/compose.hpp
index e5559c1785e1882b2af475e71191d84249cf93c2..3df2f076128f8ec2dfd8822f72c62e6a92b86da6 100644
--- a/boost/asio/impl/compose.hpp
+++ b/boost/asio/impl/compose.hpp
@@ -2,7 +2,7 @@
 // impl/compose.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,7 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/associated_executor.hpp>
+#include <boost/asio/detail/base_from_cancellation_state.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>
@@ -63,6 +64,26 @@ namespace detail
     executor_type executor_;
   };
 
+  template <>
+  struct composed_work_guard<system_executor>
+  {
+  public:
+    typedef system_executor executor_type;
+
+    composed_work_guard(const system_executor&)
+    {
+    }
+
+    void reset()
+    {
+    }
+
+    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return system_executor();
+    }
+  };
+
 #if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 
   template <typename Executor>
@@ -294,13 +315,16 @@ namespace detail
   template <typename Impl, typename Work, typename Handler, typename Signature>
   class composed_op
 #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+    : public base_from_cancellation_state<Handler>
   {
   public:
     template <typename I, typename W, typename H>
     composed_op(BOOST_ASIO_MOVE_ARG(I) impl,
         BOOST_ASIO_MOVE_ARG(W) work,
         BOOST_ASIO_MOVE_ARG(H) handler)
-      : impl_(BOOST_ASIO_MOVE_CAST(I)(impl)),
+      : base_from_cancellation_state<Handler>(
+          handler, enable_terminal_cancellation()),
+        impl_(BOOST_ASIO_MOVE_CAST(I)(impl)),
         work_(BOOST_ASIO_MOVE_CAST(W)(work)),
         handler_(BOOST_ASIO_MOVE_CAST(H)(handler)),
         invocations_(0)
@@ -309,7 +333,10 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     composed_op(composed_op&& other)
-      : impl_(BOOST_ASIO_MOVE_CAST(Impl)(other.impl_)),
+      : base_from_cancellation_state<Handler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            Handler>)(other)),
+        impl_(BOOST_ASIO_MOVE_CAST(Impl)(other.impl_)),
         work_(BOOST_ASIO_MOVE_CAST(Work)(other.work_)),
         handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)),
         invocations_(other.invocations_)
@@ -343,13 +370,15 @@ namespace detail
     {
       if (invocations_ < ~0u)
         ++invocations_;
+      this->get_cancellation_state().slot().clear();
       impl_(*this, BOOST_ASIO_MOVE_CAST(T)(t)...);
     }
 
     void complete(Args... args)
     {
       this->work_.reset();
-      this->handler_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(this->handler_)(
+          BOOST_ASIO_MOVE_CAST(Args)(args)...);
     }
 
 #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
@@ -358,13 +387,14 @@ namespace detail
     {
       if (invocations_ < ~0u)
         ++invocations_;
+      this->get_cancellation_state().slot().clear();
       impl_(*this);
     }
 
     void complete()
     {
       this->work_.reset();
-      this->handler_();
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(this->handler_)();
     }
 
 #define BOOST_ASIO_PRIVATE_COMPOSED_OP_DEF(n) \
@@ -373,6 +403,7 @@ namespace detail
     { \
       if (invocations_ < ~0u) \
         ++invocations_; \
+      this->get_cancellation_state().slot().clear(); \
       impl_(*this, BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
     } \
     \
@@ -380,7 +411,8 @@ namespace detail
     void complete(BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
     { \
       this->work_.reset(); \
-      this->handler_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(this->handler_)( \
+          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
     } \
     /**/
     BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_COMPOSED_OP_DEF)
@@ -388,6 +420,27 @@ namespace detail
 
 #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
+    void reset_cancellation_state()
+    {
+      base_from_cancellation_state<Handler>::reset_cancellation_state(handler_);
+    }
+
+    template <typename Filter>
+    void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(Filter) filter)
+    {
+      base_from_cancellation_state<Handler>::reset_cancellation_state(handler_,
+          BOOST_ASIO_MOVE_CAST(Filter)(filter));
+    }
+
+    template <typename InFilter, typename OutFilter>
+    void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
+        BOOST_ASIO_MOVE_ARG(OutFilter) out_filter)
+    {
+      base_from_cancellation_state<Handler>::reset_cancellation_state(handler_,
+          BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
+          BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter));
+    }
+
   //private:
     Impl impl_;
     Work work_;
@@ -521,6 +574,23 @@ namespace detail
 } // namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
+
+template <template <typename, typename> class Associator,
+    typename Impl, typename Work, typename Handler,
+    typename Signature, typename DefaultCandidate>
+struct associator<Associator,
+    detail::composed_op<Impl, Work, Handler, Signature>,
+    DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const detail::composed_op<Impl, Work, Handler, Signature>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
 #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename CompletionToken, typename Signature,
diff --git a/boost/asio/impl/connect.hpp b/boost/asio/impl/connect.hpp
index 231ef3d48bf716ac4a6a76f95860b188c430bbee..37f1ed9f1913e512d239eee3d063547dc12463b5 100644
--- a/boost/asio/impl/connect.hpp
+++ b/boost/asio/impl/connect.hpp
@@ -2,7 +2,7 @@
 // impl/connect.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,8 +16,8 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <algorithm>
-#include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/detail/base_from_cancellation_state.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
@@ -26,6 +26,7 @@
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/non_const_lvalue.hpp>
 #include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/post.hpp>
 
@@ -74,9 +75,9 @@ namespace detail
 
     static const bool value =
       sizeof(asio_connect_condition_check(
-        (*static_cast<legacy_connect_condition_helper<T, Iterator>*>(0))(
-          *static_cast<const boost::system::error_code*>(0),
-          *static_cast<const Iterator*>(0)))) != 1;
+        (declval<legacy_connect_condition_helper<T, Iterator> >())(
+          declval<const boost::system::error_code>(),
+          declval<const Iterator>()))) != 1;
   };
 
   template <typename ConnectCondition, typename Iterator>
@@ -295,14 +296,18 @@ namespace detail
 
   template <typename Protocol, typename Executor, typename EndpointSequence,
       typename ConnectCondition, typename RangeConnectHandler>
-  class range_connect_op : base_from_connect_condition<ConnectCondition>
+  class range_connect_op
+    : public base_from_cancellation_state<RangeConnectHandler>,
+      base_from_connect_condition<ConnectCondition>
   {
   public:
     range_connect_op(basic_socket<Protocol, Executor>& sock,
         const EndpointSequence& endpoints,
         const ConnectCondition& connect_condition,
         RangeConnectHandler& handler)
-      : base_from_connect_condition<ConnectCondition>(connect_condition),
+      : base_from_cancellation_state<RangeConnectHandler>(
+          handler, enable_partial_cancellation()),
+        base_from_connect_condition<ConnectCondition>(connect_condition),
         socket_(sock),
         endpoints_(endpoints),
         index_(0),
@@ -313,7 +318,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     range_connect_op(const range_connect_op& other)
-      : base_from_connect_condition<ConnectCondition>(other),
+      : base_from_cancellation_state<RangeConnectHandler>(other),
+        base_from_connect_condition<ConnectCondition>(other),
         socket_(other.socket_),
         endpoints_(other.endpoints_),
         index_(other.index_),
@@ -323,7 +329,10 @@ namespace detail
     }
 
     range_connect_op(range_connect_op&& other)
-      : base_from_connect_condition<ConnectCondition>(other),
+      : base_from_cancellation_state<RangeConnectHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            RangeConnectHandler>)(other)),
+        base_from_connect_condition<ConnectCondition>(other),
         socket_(other.socket_),
         endpoints_(other.endpoints_),
         index_(other.index_),
@@ -389,11 +398,18 @@ namespace detail
           if (!ec)
             break;
 
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = boost::asio::error::operation_aborted;
+            break;
+          }
+
           ++iter;
           ++index_;
         }
 
-        handler_(static_cast<const boost::system::error_code&>(ec),
+        BOOST_ASIO_MOVE_OR_LVALUE(RangeConnectHandler)(handler_)(
+            static_cast<const boost::system::error_code&>(ec),
             static_cast<const typename Protocol::endpoint&>(
               ec || iter == end ? typename Protocol::endpoint() : *iter));
       }
@@ -516,14 +532,18 @@ namespace detail
 
   template <typename Protocol, typename Executor, typename Iterator,
       typename ConnectCondition, typename IteratorConnectHandler>
-  class iterator_connect_op : base_from_connect_condition<ConnectCondition>
+  class iterator_connect_op
+    : public base_from_cancellation_state<IteratorConnectHandler>,
+      base_from_connect_condition<ConnectCondition>
   {
   public:
     iterator_connect_op(basic_socket<Protocol, Executor>& sock,
         const Iterator& begin, const Iterator& end,
         const ConnectCondition& connect_condition,
         IteratorConnectHandler& handler)
-      : base_from_connect_condition<ConnectCondition>(connect_condition),
+      : base_from_cancellation_state<IteratorConnectHandler>(
+          handler, enable_partial_cancellation()),
+        base_from_connect_condition<ConnectCondition>(connect_condition),
         socket_(sock),
         iter_(begin),
         end_(end),
@@ -534,7 +554,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     iterator_connect_op(const iterator_connect_op& other)
-      : base_from_connect_condition<ConnectCondition>(other),
+      : base_from_cancellation_state<IteratorConnectHandler>(other),
+        base_from_connect_condition<ConnectCondition>(other),
         socket_(other.socket_),
         iter_(other.iter_),
         end_(other.end_),
@@ -544,7 +565,10 @@ namespace detail
     }
 
     iterator_connect_op(iterator_connect_op&& other)
-      : base_from_connect_condition<ConnectCondition>(other),
+      : base_from_cancellation_state<IteratorConnectHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            IteratorConnectHandler>)(other)),
+        base_from_connect_condition<ConnectCondition>(other),
         socket_(other.socket_),
         iter_(other.iter_),
         end_(other.end_),
@@ -596,10 +620,17 @@ namespace detail
           if (!ec)
             break;
 
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = boost::asio::error::operation_aborted;
+            break;
+          }
+
           ++iter_;
         }
 
-        handler_(static_cast<const boost::system::error_code&>(ec),
+        BOOST_ASIO_MOVE_OR_LVALUE(IteratorConnectHandler)(handler_)(
+            static_cast<const boost::system::error_code&>(ec),
             static_cast<const Iterator&>(iter_));
       }
     }
@@ -724,86 +755,44 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename Protocol, typename Executor, typename EndpointSequence,
-    typename ConnectCondition, typename RangeConnectHandler, typename Allocator>
-struct associated_allocator<
-    detail::range_connect_op<Protocol, Executor, EndpointSequence,
-      ConnectCondition, RangeConnectHandler>, Allocator>
+template <template <typename, typename> class Associator,
+    typename Protocol, typename Executor, typename EndpointSequence,
+    typename ConnectCondition, typename RangeConnectHandler,
+    typename DefaultCandidate>
+struct associator<Associator,
+    detail::range_connect_op<Protocol, Executor,
+      EndpointSequence, ConnectCondition, RangeConnectHandler>,
+    DefaultCandidate>
+  : Associator<RangeConnectHandler, DefaultCandidate>
 {
-  typedef typename associated_allocator<
-      RangeConnectHandler, Allocator>::type type;
-
-  static type get(
-      const detail::range_connect_op<Protocol, Executor, EndpointSequence,
-        ConnectCondition, RangeConnectHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<RangeConnectHandler, DefaultCandidate>::type get(
+      const detail::range_connect_op<Protocol, Executor,
+        EndpointSequence, ConnectCondition, RangeConnectHandler>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<RangeConnectHandler,
-        Allocator>::get(h.handler_, a);
+    return Associator<RangeConnectHandler, DefaultCandidate>::get(
+        h.handler_, c);
   }
 };
 
-template <typename Protocol, typename Executor, typename EndpointSequence,
-    typename ConnectCondition, typename RangeConnectHandler, typename Executor1>
-struct associated_executor<
-    detail::range_connect_op<Protocol, Executor, EndpointSequence,
-      ConnectCondition, RangeConnectHandler>, Executor1>
-  : detail::associated_executor_forwarding_base<RangeConnectHandler, Executor1>
-{
-  typedef typename associated_executor<
-      RangeConnectHandler, Executor1>::type type;
-
-  static type get(
-      const detail::range_connect_op<Protocol, Executor, EndpointSequence,
-      ConnectCondition, RangeConnectHandler>& h,
-      const Executor1& ex = Executor1()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_executor<RangeConnectHandler,
-        Executor1>::get(h.handler_, ex);
-  }
-};
-
-template <typename Protocol, typename Executor, typename Iterator,
-    typename ConnectCondition, typename IteratorConnectHandler,
-    typename Allocator>
-struct associated_allocator<
-    detail::iterator_connect_op<Protocol, Executor,
-      Iterator, ConnectCondition, IteratorConnectHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<
-      IteratorConnectHandler, Allocator>::type type;
-
-  static type get(
-      const detail::iterator_connect_op<Protocol, Executor,
-        Iterator, ConnectCondition, IteratorConnectHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<IteratorConnectHandler,
-        Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename Protocol, typename Executor, typename Iterator,
+template <template <typename, typename> class Associator,
+    typename Protocol, typename Executor, typename Iterator,
     typename ConnectCondition, typename IteratorConnectHandler,
-    typename Executor1>
-struct associated_executor<
+    typename DefaultCandidate>
+struct associator<Associator,
     detail::iterator_connect_op<Protocol, Executor,
       Iterator, ConnectCondition, IteratorConnectHandler>,
-    Executor1>
-  : detail::associated_executor_forwarding_base<
-      IteratorConnectHandler, Executor1>
+    DefaultCandidate>
+  : Associator<IteratorConnectHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<
-      IteratorConnectHandler, Executor1>::type type;
-
-  static type get(
+  static typename Associator<IteratorConnectHandler, DefaultCandidate>::type
+  get(
       const detail::iterator_connect_op<Protocol, Executor,
         Iterator, ConnectCondition, IteratorConnectHandler>& h,
-      const Executor1& ex = Executor1()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<IteratorConnectHandler,
-        Executor1>::get(h.handler_, ex);
+    return Associator<IteratorConnectHandler, DefaultCandidate>::get(
+        h.handler_, c);
   }
 };
 
@@ -811,103 +800,103 @@ struct associated_executor<
 
 template <typename Protocol, typename Executor, typename EndpointSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      typename Protocol::endpoint)) RangeConnectHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(RangeConnectHandler,
+      typename Protocol::endpoint)) RangeConnectToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(RangeConnectToken,
     void (boost::system::error_code, typename Protocol::endpoint))
 async_connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints,
-    BOOST_ASIO_MOVE_ARG(RangeConnectHandler) handler,
+    BOOST_ASIO_MOVE_ARG(RangeConnectToken) token,
     typename constraint<is_endpoint_sequence<
         EndpointSequence>::value>::type)
 {
-  return async_initiate<RangeConnectHandler,
+  return async_initiate<RangeConnectToken,
     void (boost::system::error_code, typename Protocol::endpoint)>(
       detail::initiate_async_range_connect<Protocol, Executor>(s),
-      handler, endpoints, detail::default_connect_condition());
+      token, endpoints, detail::default_connect_condition());
 }
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 template <typename Protocol, typename Executor, typename Iterator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      Iterator)) IteratorConnectHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectHandler,
+      Iterator)) IteratorConnectToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler,
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token,
     typename constraint<!is_endpoint_sequence<Iterator>::value>::type)
 {
-  return async_initiate<IteratorConnectHandler,
+  return async_initiate<IteratorConnectToken,
     void (boost::system::error_code, Iterator)>(
       detail::initiate_async_iterator_connect<Protocol, Executor>(s),
-      handler, begin, Iterator(), detail::default_connect_condition());
+      token, begin, Iterator(), detail::default_connect_condition());
 }
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
 template <typename Protocol, typename Executor, typename Iterator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      Iterator)) IteratorConnectHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectHandler,
+      Iterator)) IteratorConnectToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler)
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token)
 {
-  return async_initiate<IteratorConnectHandler,
+  return async_initiate<IteratorConnectToken,
     void (boost::system::error_code, Iterator)>(
       detail::initiate_async_iterator_connect<Protocol, Executor>(s),
-      handler, begin, end, detail::default_connect_condition());
+      token, begin, end, detail::default_connect_condition());
 }
 
 template <typename Protocol, typename Executor,
     typename EndpointSequence, typename ConnectCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      typename Protocol::endpoint)) RangeConnectHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(RangeConnectHandler,
+      typename Protocol::endpoint)) RangeConnectToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(RangeConnectToken,
     void (boost::system::error_code, typename Protocol::endpoint))
 async_connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints, ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(RangeConnectHandler) handler,
+    BOOST_ASIO_MOVE_ARG(RangeConnectToken) token,
     typename constraint<is_endpoint_sequence<
         EndpointSequence>::value>::type)
 {
-  return async_initiate<RangeConnectHandler,
+  return async_initiate<RangeConnectToken,
     void (boost::system::error_code, typename Protocol::endpoint)>(
       detail::initiate_async_range_connect<Protocol, Executor>(s),
-      handler, endpoints, connect_condition);
+      token, endpoints, connect_condition);
 }
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      Iterator)) IteratorConnectHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectHandler,
+      Iterator)) IteratorConnectToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
     ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler,
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token,
     typename constraint<!is_endpoint_sequence<Iterator>::value>::type)
 {
-  return async_initiate<IteratorConnectHandler,
+  return async_initiate<IteratorConnectToken,
     void (boost::system::error_code, Iterator)>(
       detail::initiate_async_iterator_connect<Protocol, Executor>(s),
-      handler, begin, Iterator(), connect_condition);
+      token, begin, Iterator(), connect_condition);
 }
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
 template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      Iterator)) IteratorConnectHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectHandler,
+      Iterator)) IteratorConnectToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
     Iterator end, ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler)
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token)
 {
-  return async_initiate<IteratorConnectHandler,
+  return async_initiate<IteratorConnectToken,
     void (boost::system::error_code, Iterator)>(
       detail::initiate_async_iterator_connect<Protocol, Executor>(s),
-      handler, begin, end, connect_condition);
+      token, begin, end, connect_condition);
 }
 
 } // namespace asio
diff --git a/boost/asio/impl/connect_pipe.hpp b/boost/asio/impl/connect_pipe.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..419857cc410fa0446c58f58d3225adf0a6076ba4
--- /dev/null
+++ b/boost/asio/impl/connect_pipe.hpp
@@ -0,0 +1,75 @@
+//
+// impl/connect_pipe.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IMPL_CONNECT_PIPE_HPP
+#define BOOST_ASIO_IMPL_CONNECT_PIPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_PIPE)
+
+#include <boost/asio/connect_pipe.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename Executor1, typename Executor2>
+void connect_pipe(basic_readable_pipe<Executor1>& read_end,
+    basic_writable_pipe<Executor2>& write_end)
+{
+  boost::system::error_code ec;
+  boost::asio::connect_pipe(read_end, write_end, ec);
+  boost::asio::detail::throw_error(ec, "connect_pipe");
+}
+
+template <typename Executor1, typename Executor2>
+BOOST_ASIO_SYNC_OP_VOID connect_pipe(basic_readable_pipe<Executor1>& read_end,
+    basic_writable_pipe<Executor2>& write_end, boost::system::error_code& ec)
+{
+  detail::native_pipe_handle p[2];
+  detail::create_pipe(p, ec);
+  if (ec)
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+
+  read_end.assign(p[0], ec);
+  if (ec)
+  {
+    detail::close_pipe(p[0]);
+    detail::close_pipe(p[1]);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  write_end.assign(p[1], ec);
+  if (ec)
+  {
+    boost::system::error_code temp_ec;
+    read_end.close(temp_ec);
+    detail::close_pipe(p[1]);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_PIPE)
+
+#endif // BOOST_ASIO_IMPL_CONNECT_PIPE_HPP
diff --git a/boost/asio/impl/connect_pipe.ipp b/boost/asio/impl/connect_pipe.ipp
new file mode 100644
index 0000000000000000000000000000000000000000..ff808295922b000a98cab7fcbf0f0b8f55c496c9
--- /dev/null
+++ b/boost/asio/impl/connect_pipe.ipp
@@ -0,0 +1,151 @@
+//
+// impl/connect_pipe.ipp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2021 Klemens D. Morgenstern
+//                    (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IMPL_CONNECT_PIPE_IPP
+#define BOOST_ASIO_IMPL_CONNECT_PIPE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_PIPE)
+
+#include <boost/asio/connect_pipe.hpp>
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <cstdio>
+# if _WIN32_WINNT >= 0x601
+#  include <bcrypt.h>
+#  if !defined(BOOST_ASIO_NO_DEFAULT_LINKED_LIBS)
+#   if defined(_MSC_VER)
+#    pragma comment(lib, "bcrypt.lib")
+#   endif // defined(_MSC_VER)
+#  endif // !defined(BOOST_ASIO_NO_DEFAULT_LINKED_LIBS)
+# endif // _WIN32_WINNT >= 0x601
+#else // defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/descriptor_ops.hpp>
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+void create_pipe(native_pipe_handle p[2], boost::system::error_code& ec)
+{
+#if defined(BOOST_ASIO_HAS_IOCP)
+  using namespace std; // For sprintf and memcmp.
+
+  static long counter1 = 0;
+  static long counter2 = 0;
+
+  long n1 = ::InterlockedIncrement(&counter1);
+  long n2 = (static_cast<unsigned long>(n1) % 0x10000000) == 0
+    ? ::InterlockedIncrement(&counter2)
+    : ::InterlockedExchangeAdd(&counter2, 0);
+
+  wchar_t pipe_name[128];
+#if defined(BOOST_ASIO_HAS_SECURE_RTL)
+  swprintf_s(
+#else // defined(BOOST_ASIO_HAS_SECURE_RTL)
+  _snwprintf(
+#endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
+      pipe_name, 128,
+      L"\\\\.\\pipe\\asio-A0812896-741A-484D-AF23-BE51BF620E22-%u-%ld-%ld",
+      static_cast<unsigned int>(::GetCurrentProcessId()), n1, n2);
+
+  p[0] = ::CreateNamedPipeW(pipe_name,
+      PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
+      0, 1, 8192, 8192, 0, 0);
+
+  if (p[0] == INVALID_HANDLE_VALUE)
+  {
+    DWORD last_error = ::GetLastError();
+    ec.assign(last_error, boost::asio::error::get_system_category());
+    return;
+  }
+
+  p[1] = ::CreateFileW(pipe_name, GENERIC_WRITE, 0,
+    0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
+
+  if (p[1] == INVALID_HANDLE_VALUE)
+  {
+    DWORD last_error = ::GetLastError();
+    ::CloseHandle(p[0]);
+    ec.assign(last_error, boost::asio::error::get_system_category());
+    return;
+  }
+
+# if _WIN32_WINNT >= 0x601
+  unsigned char nonce[16];
+  if (::BCryptGenRandom(0, nonce, sizeof(nonce),
+        BCRYPT_USE_SYSTEM_PREFERRED_RNG) != 0)
+  {
+    ec = boost::asio::error::connection_aborted;
+    ::CloseHandle(p[0]);
+    ::CloseHandle(p[1]);
+    return;
+  }
+
+  DWORD bytes_written = 0;
+  BOOL ok = ::WriteFile(p[1], nonce, sizeof(nonce), &bytes_written, 0);
+  if (!ok || bytes_written != sizeof(nonce))
+  {
+    ec = boost::asio::error::connection_aborted;
+    ::CloseHandle(p[0]);
+    ::CloseHandle(p[1]);
+    return;
+  }
+
+  unsigned char nonce_check[sizeof(nonce)];
+  DWORD bytes_read = 0;
+  ok = ::ReadFile(p[0], nonce_check, sizeof(nonce), &bytes_read, 0);
+  if (!ok || bytes_read != sizeof(nonce)
+      || memcmp(nonce, nonce_check, sizeof(nonce)) != 0)
+  {
+    ec = boost::asio::error::connection_aborted;
+    ::CloseHandle(p[0]);
+    ::CloseHandle(p[1]);
+    return;
+  }
+#endif // _WIN32_WINNT >= 0x601
+
+  ec.assign(0, ec.category());
+#else // defined(BOOST_ASIO_HAS_IOCP)
+  int result = ::pipe(p);
+  detail::descriptor_ops::get_last_error(ec, result != 0);
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+}
+
+void close_pipe(native_pipe_handle p)
+{
+#if defined(BOOST_ASIO_HAS_IOCP)
+  ::CloseHandle(p);
+#else // defined(BOOST_ASIO_HAS_IOCP)
+  boost::system::error_code ignored_ec;
+  detail::descriptor_ops::state_type state = 0;
+  detail::descriptor_ops::close(p, state, ignored_ec);
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_PIPE)
+
+#endif // BOOST_ASIO_IMPL_CONNECT_PIPE_IPP
diff --git a/boost/asio/impl/defer.hpp b/boost/asio/impl/defer.hpp
index 7537afe29fe5abd046a006ff5579af61ca34bce1..8a00645cac8827fe57fe81be122f1503f82328aa 100644
--- a/boost/asio/impl/defer.hpp
+++ b/boost/asio/impl/defer.hpp
@@ -2,7 +2,7 @@
 // impl/defer.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -57,7 +57,8 @@ public:
           boost::asio::require(ex, execution::blocking.never),
           execution::relationship.continuation,
           execution::allocator(alloc)),
-        BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+        boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)));
   }
 
   template <typename CompletionHandler>
@@ -78,7 +79,8 @@ public:
     typename associated_allocator<handler_t>::type alloc(
         (get_associated_allocator)(handler));
 
-    ex.defer(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler), alloc);
+    ex.defer(boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)), alloc);
   }
 };
 
@@ -122,7 +124,8 @@ public:
           boost::asio::require(ex_, execution::blocking.never),
           execution::relationship.continuation,
           execution::allocator(alloc)),
-        BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+        boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)));
   }
 
   template <typename CompletionHandler>
@@ -176,7 +179,8 @@ public:
     typename associated_allocator<handler_t>::type alloc(
         (get_associated_allocator)(handler));
 
-    ex_.defer(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler), alloc);
+    ex_.defer(boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)), alloc);
   }
 
   template <typename CompletionHandler>
@@ -213,34 +217,34 @@ private:
 
 } // namespace detail
 
-template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) defer(
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token)
+template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) defer(
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token)
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_defer(), token);
 }
 
 template <typename Executor,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) defer(
-    const Executor& ex, BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) defer(
+    const Executor& ex, BOOST_ASIO_MOVE_ARG(NullaryToken) token,
     typename constraint<
       execution::is_executor<Executor>::value || is_executor<Executor>::value
     >::type)
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_defer_with_executor<Executor>(ex), token);
 }
 
 template <typename ExecutionContext,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) defer(
-    ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) defer(
+    ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(NullaryToken) token,
     typename constraint<is_convertible<
       ExecutionContext&, execution_context&>::value>::type)
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_defer_with_executor<
         typename ExecutionContext::executor_type>(
           ctx.get_executor()), token);
diff --git a/boost/asio/impl/detached.hpp b/boost/asio/impl/detached.hpp
index 38e057cc78cdb25498f4f0b5e09a684803fcddeb..f8c5562ac8bf8c946bb5b9dc66198577bc719b6c 100644
--- a/boost/asio/impl/detached.hpp
+++ b/boost/asio/impl/detached.hpp
@@ -2,7 +2,7 @@
 // impl/detached.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/dispatch.hpp b/boost/asio/impl/dispatch.hpp
index d0357d4d36c4b39eac0f497bd86d11f20d0d46c3..589d6f15312f8cad0c8695e6f207c2aa1688ed13 100644
--- a/boost/asio/impl/dispatch.hpp
+++ b/boost/asio/impl/dispatch.hpp
@@ -2,7 +2,7 @@
 // impl/dispatch.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -54,7 +54,8 @@ public:
         boost::asio::prefer(ex,
           execution::blocking.possibly,
           execution::allocator(alloc)),
-        BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+        boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)));
   }
 
   template <typename CompletionHandler>
@@ -75,7 +76,8 @@ public:
     typename associated_allocator<handler_t>::type alloc(
         (get_associated_allocator)(handler));
 
-    ex.dispatch(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler), alloc);
+    ex.dispatch(boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)), alloc);
   }
 };
 
@@ -118,7 +120,8 @@ public:
         boost::asio::prefer(ex_,
           execution::blocking.possibly,
           execution::allocator(alloc)),
-        BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+        boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)));
   }
 
   template <typename CompletionHandler>
@@ -171,7 +174,8 @@ public:
     typename associated_allocator<handler_t>::type alloc(
         (get_associated_allocator)(handler));
 
-    ex_.dispatch(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler), alloc);
+    ex_.dispatch(boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)), alloc);
   }
 
   template <typename CompletionHandler>
@@ -208,34 +212,34 @@ private:
 
 } // namespace detail
 
-template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) dispatch(
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token)
+template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) dispatch(
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token)
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_dispatch(), token);
 }
 
 template <typename Executor,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) dispatch(
-    const Executor& ex, BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) dispatch(
+    const Executor& ex, BOOST_ASIO_MOVE_ARG(NullaryToken) token,
     typename constraint<
       execution::is_executor<Executor>::value || is_executor<Executor>::value
     >::type)
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_dispatch_with_executor<Executor>(ex), token);
 }
 
 template <typename ExecutionContext,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) dispatch(
-    ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) dispatch(
+    ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(NullaryToken) token,
     typename constraint<is_convertible<
       ExecutionContext&, execution_context&>::value>::type)
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_dispatch_with_executor<
         typename ExecutionContext::executor_type>(
           ctx.get_executor()), token);
diff --git a/boost/asio/impl/error.ipp b/boost/asio/impl/error.ipp
index b357e22126ceec641695544f9a62514819aa6c2f..082ccb05b52bb6a0fc041048e945a0768acb77ea 100644
--- a/boost/asio/impl/error.ipp
+++ b/boost/asio/impl/error.ipp
@@ -2,7 +2,7 @@
 // impl/error.ipp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/execution_context.hpp b/boost/asio/impl/execution_context.hpp
index 66874c04254bea5b7509e190ada389c1606150ef..bed35985f986a450074120589a241f7a9b98f428 100644
--- a/boost/asio/impl/execution_context.hpp
+++ b/boost/asio/impl/execution_context.hpp
@@ -2,7 +2,7 @@
 // impl/execution_context.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/execution_context.ipp b/boost/asio/impl/execution_context.ipp
index 41a6741b274205538722c7faafbb229aad590e7e..1cfefc91ba2923a823f38c9bf03a709d34c2a62d 100644
--- a/boost/asio/impl/execution_context.ipp
+++ b/boost/asio/impl/execution_context.ipp
@@ -2,7 +2,7 @@
 // impl/execution_context.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/executor.hpp b/boost/asio/impl/executor.hpp
index 964bb53e44857473668ccd4f325c45c42fe74045..a514a1ff75a6666c71b48ad22e59832eee7c9a66 100644
--- a/boost/asio/impl/executor.hpp
+++ b/boost/asio/impl/executor.hpp
@@ -2,7 +2,7 @@
 // impl/executor.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/executor.ipp b/boost/asio/impl/executor.ipp
index 5083dcb1b898a4dcb62a0042772b82818f3966d3..f463a9f07ccb02490f25ae800610738dbc888318 100644
--- a/boost/asio/impl/executor.ipp
+++ b/boost/asio/impl/executor.ipp
@@ -2,7 +2,7 @@
 // impl/executor.ipp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/handler_alloc_hook.ipp b/boost/asio/impl/handler_alloc_hook.ipp
index 531769bc9742cc7cf1cda80b67aae22cb6255cd6..a44e278b90f7fd51c03b87f7b0eeb68b454def54 100644
--- a/boost/asio/impl/handler_alloc_hook.ipp
+++ b/boost/asio/impl/handler_alloc_hook.ipp
@@ -2,7 +2,7 @@
 // impl/handler_alloc_hook.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,6 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/memory.hpp>
 #include <boost/asio/detail/thread_context.hpp>
 #include <boost/asio/detail/thread_info_base.hpp>
 #include <boost/asio/handler_alloc_hook.hpp>
@@ -35,7 +36,7 @@ asio_handler_allocate(std::size_t size, ...)
   return detail::thread_info_base::allocate(
       detail::thread_context::top_of_thread_call_stack(), size);
 #else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-  return ::operator new(size);
+  return aligned_new(BOOST_ASIO_DEFAULT_ALIGN, size);
 #endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
 }
 
@@ -51,7 +52,7 @@ asio_handler_deallocate(void* pointer, std::size_t size, ...)
       detail::thread_context::top_of_thread_call_stack(), pointer, size);
 #else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
   (void)size;
-  ::operator delete(pointer);
+  aligned_delete(pointer)
 #endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
 }
 
diff --git a/boost/asio/impl/io_context.hpp b/boost/asio/impl/io_context.hpp
index 0b4148916e64beea6dcc77e50529b68ac9b2181e..8ccd5627af0ce89f9402816b2e8d130032f3dade 100644
--- a/boost/asio/impl/io_context.hpp
+++ b/boost/asio/impl/io_context.hpp
@@ -2,7 +2,7 @@
 // impl/io_context.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -214,21 +214,20 @@ io_context::wrap(Handler handler)
 
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 io_context::basic_executor_type<Allocator, Bits>&
 io_context::basic_executor_type<Allocator, Bits>::operator=(
     const basic_executor_type& other) BOOST_ASIO_NOEXCEPT
 {
   if (this != &other)
   {
-    io_context* old_io_context = io_context_;
-    io_context_ = other.io_context_;
-    allocator_ = other.allocator_;
-    bits_ = other.bits_;
+    static_cast<Allocator&>(*this) = static_cast<const Allocator&>(other);
+    io_context* old_io_context = context_ptr();
+    target_ = other.target_;
     if (Bits & outstanding_work_tracked)
     {
-      if (io_context_)
-        io_context_->impl_.work_started();
+      if (context_ptr())
+        context_ptr()->impl_.work_started();
       if (old_io_context)
         old_io_context->impl_.work_finished();
     }
@@ -237,20 +236,19 @@ io_context::basic_executor_type<Allocator, Bits>::operator=(
 }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 io_context::basic_executor_type<Allocator, Bits>&
 io_context::basic_executor_type<Allocator, Bits>::operator=(
     basic_executor_type&& other) BOOST_ASIO_NOEXCEPT
 {
   if (this != &other)
   {
-    io_context* old_io_context = io_context_;
-    io_context_ = other.io_context_;
-    allocator_ = std::move(other.allocator_);
-    bits_ = other.bits_;
+    static_cast<Allocator&>(*this) = static_cast<Allocator&&>(other);
+    io_context* old_io_context = context_ptr();
+    target_ = other.target_;
     if (Bits & outstanding_work_tracked)
     {
-      other.io_context_ = 0;
+      other.target_ = 0;
       if (old_io_context)
         old_io_context->impl_.work_finished();
     }
@@ -259,14 +257,14 @@ io_context::basic_executor_type<Allocator, Bits>::operator=(
 }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 inline bool io_context::basic_executor_type<Allocator,
     Bits>::running_in_this_thread() const BOOST_ASIO_NOEXCEPT
 {
-  return io_context_->impl_.can_dispatch();
+  return context_ptr()->impl_.can_dispatch();
 }
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 template <typename Function>
 void io_context::basic_executor_type<Allocator, Bits>::execute(
     BOOST_ASIO_MOVE_ARG(Function) f) const
@@ -275,7 +273,7 @@ void io_context::basic_executor_type<Allocator, Bits>::execute(
 
   // Invoke immediately if the blocking.possibly property is enabled and we are
   // already inside the thread pool.
-  if ((bits_ & blocking_never) == 0 && io_context_->impl_.can_dispatch())
+  if ((bits() & blocking_never) == 0 && context_ptr()->impl_.can_dispatch())
   {
     // Make a local, non-const copy of the function.
     function_type tmp(BOOST_ASIO_MOVE_CAST(Function)(f));
@@ -294,7 +292,7 @@ void io_context::basic_executor_type<Allocator, Bits>::execute(
     }
     catch (...)
     {
-      io_context_->impl_.capture_current_exception();
+      context_ptr()->impl_.capture_current_exception();
       return;
     }
 #endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR)
@@ -303,41 +301,43 @@ void io_context::basic_executor_type<Allocator, Bits>::execute(
 
   // Allocate and construct an operation to wrap the function.
   typedef detail::executor_op<function_type, Allocator, detail::operation> op;
-  typename op::ptr p = { detail::addressof(allocator_),
-      op::ptr::allocate(allocator_), 0 };
-  p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), allocator_);
+  typename op::ptr p = {
+      detail::addressof(static_cast<const Allocator&>(*this)),
+      op::ptr::allocate(static_cast<const Allocator&>(*this)), 0 };
+  p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f),
+      static_cast<const Allocator&>(*this));
 
-  BOOST_ASIO_HANDLER_CREATION((*io_context_, *p.p,
-        "io_context", io_context_, 0, "execute"));
+  BOOST_ASIO_HANDLER_CREATION((*context_ptr(), *p.p,
+        "io_context", context_ptr(), 0, "execute"));
 
-  io_context_->impl_.post_immediate_completion(p.p,
-      (bits_ & relationship_continuation) != 0);
+  context_ptr()->impl_.post_immediate_completion(p.p,
+      (bits() & relationship_continuation) != 0);
   p.v = p.p = 0;
 }
 
 #if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 inline io_context& io_context::basic_executor_type<
     Allocator, Bits>::context() const BOOST_ASIO_NOEXCEPT
 {
-  return *io_context_;
+  return *context_ptr();
 }
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 inline void io_context::basic_executor_type<Allocator,
     Bits>::on_work_started() const BOOST_ASIO_NOEXCEPT
 {
-  io_context_->impl_.work_started();
+  context_ptr()->impl_.work_started();
 }
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 inline void io_context::basic_executor_type<Allocator,
     Bits>::on_work_finished() const BOOST_ASIO_NOEXCEPT
 {
-  io_context_->impl_.work_finished();
+  context_ptr()->impl_.work_finished();
 }
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 template <typename Function, typename OtherAllocator>
 void io_context::basic_executor_type<Allocator, Bits>::dispatch(
     BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
@@ -345,7 +345,7 @@ void io_context::basic_executor_type<Allocator, Bits>::dispatch(
   typedef typename decay<Function>::type function_type;
 
   // Invoke immediately if we are already inside the thread pool.
-  if (io_context_->impl_.can_dispatch())
+  if (context_ptr()->impl_.can_dispatch())
   {
     // Make a local, non-const copy of the function.
     function_type tmp(BOOST_ASIO_MOVE_CAST(Function)(f));
@@ -361,14 +361,14 @@ void io_context::basic_executor_type<Allocator, Bits>::dispatch(
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
   p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), a);
 
-  BOOST_ASIO_HANDLER_CREATION((*io_context_, *p.p,
-        "io_context", io_context_, 0, "dispatch"));
+  BOOST_ASIO_HANDLER_CREATION((*context_ptr(), *p.p,
+        "io_context", context_ptr(), 0, "dispatch"));
 
-  io_context_->impl_.post_immediate_completion(p.p, false);
+  context_ptr()->impl_.post_immediate_completion(p.p, false);
   p.v = p.p = 0;
 }
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 template <typename Function, typename OtherAllocator>
 void io_context::basic_executor_type<Allocator, Bits>::post(
     BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
@@ -381,14 +381,14 @@ void io_context::basic_executor_type<Allocator, Bits>::post(
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
   p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), a);
 
-  BOOST_ASIO_HANDLER_CREATION((*io_context_, *p.p,
-        "io_context", io_context_, 0, "post"));
+  BOOST_ASIO_HANDLER_CREATION((*context_ptr(), *p.p,
+        "io_context", context_ptr(), 0, "post"));
 
-  io_context_->impl_.post_immediate_completion(p.p, false);
+  context_ptr()->impl_.post_immediate_completion(p.p, false);
   p.v = p.p = 0;
 }
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 template <typename Function, typename OtherAllocator>
 void io_context::basic_executor_type<Allocator, Bits>::defer(
     BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
@@ -401,10 +401,10 @@ void io_context::basic_executor_type<Allocator, Bits>::defer(
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
   p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), a);
 
-  BOOST_ASIO_HANDLER_CREATION((*io_context_, *p.p,
-        "io_context", io_context_, 0, "defer"));
+  BOOST_ASIO_HANDLER_CREATION((*context_ptr(), *p.p,
+        "io_context", context_ptr(), 0, "defer"));
 
-  io_context_->impl_.post_immediate_completion(p.p, true);
+  context_ptr()->impl_.post_immediate_completion(p.p, true);
   p.v = p.p = 0;
 }
 #endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS)
diff --git a/boost/asio/impl/io_context.ipp b/boost/asio/impl/io_context.ipp
index 02ec0455f28258538ab1db04ddebea3c5d5b4151..1331798b212a1a26cb0bd6c938c648f86f0eb50e 100644
--- a/boost/asio/impl/io_context.ipp
+++ b/boost/asio/impl/io_context.ipp
@@ -2,7 +2,7 @@
 // impl/io_context.ipp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/multiple_exceptions.ipp b/boost/asio/impl/multiple_exceptions.ipp
index 02d49722164640cbb696457e73664bd3f7cdabd6..ab59b17f1a3f6eaaf5d40c055962fea0bdddc87e 100644
--- a/boost/asio/impl/multiple_exceptions.ipp
+++ b/boost/asio/impl/multiple_exceptions.ipp
@@ -2,7 +2,7 @@
 // impl/multiple_exceptions.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/post.hpp b/boost/asio/impl/post.hpp
index b85965c8b37ea645e1baa0bcbd4aa82bbbdab859..8c4a0baad689e14c0a8c63fc3cc67bef95c17ba6 100644
--- a/boost/asio/impl/post.hpp
+++ b/boost/asio/impl/post.hpp
@@ -2,7 +2,7 @@
 // impl/post.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -57,7 +57,8 @@ public:
           boost::asio::require(ex, execution::blocking.never),
           execution::relationship.fork,
           execution::allocator(alloc)),
-        BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+        boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)));
   }
 
   template <typename CompletionHandler>
@@ -78,7 +79,8 @@ public:
     typename associated_allocator<handler_t>::type alloc(
         (get_associated_allocator)(handler));
 
-    ex.post(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler), alloc);
+    ex.post(boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)), alloc);
   }
 };
 
@@ -122,7 +124,8 @@ public:
           boost::asio::require(ex_, execution::blocking.never),
           execution::relationship.fork,
           execution::allocator(alloc)),
-        BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+        boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)));
   }
 
   template <typename CompletionHandler>
@@ -176,7 +179,8 @@ public:
     typename associated_allocator<handler_t>::type alloc(
         (get_associated_allocator)(handler));
 
-    ex_.post(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler), alloc);
+    ex_.post(boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)), alloc);
   }
 
   template <typename CompletionHandler>
@@ -213,34 +217,34 @@ private:
 
 } // namespace detail
 
-template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token)
+template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) post(
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token)
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_post(), token);
 }
 
 template <typename Executor,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
-    const Executor& ex, BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) post(
+    const Executor& ex, BOOST_ASIO_MOVE_ARG(NullaryToken) token,
     typename constraint<
       execution::is_executor<Executor>::value || is_executor<Executor>::value
     >::type)
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_post_with_executor<Executor>(ex), token);
 }
 
 template <typename ExecutionContext,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
-    ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) post(
+    ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(NullaryToken) token,
     typename constraint<is_convertible<
       ExecutionContext&, execution_context&>::value>::type)
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_post_with_executor<
         typename ExecutionContext::executor_type>(
           ctx.get_executor()), token);
diff --git a/boost/asio/impl/read.hpp b/boost/asio/impl/read.hpp
index aec2afc5de7f232adc3209d0f7d789cffe0fe08a..c6ca3db903e1f47ed9c065e4e63f45a38cfbad15 100644
--- a/boost/asio/impl/read.hpp
+++ b/boost/asio/impl/read.hpp
@@ -2,7 +2,7 @@
 // impl/read.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,11 +16,11 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <algorithm>
-#include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associator.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/completion_condition.hpp>
 #include <boost/asio/detail/array_fwd.hpp>
+#include <boost/asio/detail/base_from_cancellation_state.hpp>
 #include <boost/asio/detail/base_from_completion_cond.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/consuming_buffers.hpp>
@@ -324,13 +324,15 @@ namespace detail
       typename MutableBufferIterator, typename CompletionCondition,
       typename ReadHandler>
   class read_op
-    : detail::base_from_completion_cond<CompletionCondition>
+    : public base_from_cancellation_state<ReadHandler>,
+      base_from_completion_cond<CompletionCondition>
   {
   public:
     read_op(AsyncReadStream& stream, const MutableBufferSequence& buffers,
         CompletionCondition& completion_condition, ReadHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
+      : base_from_cancellation_state<ReadHandler>(
+          handler, enable_partial_cancellation()),
+        base_from_completion_cond<CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
         start_(0),
@@ -340,7 +342,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_op(const read_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
+      : base_from_cancellation_state<ReadHandler>(other),
+        base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
         start_(other.start_),
@@ -349,8 +352,11 @@ namespace detail
     }
 
     read_op(read_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(
-          BOOST_ASIO_MOVE_CAST(detail::base_from_completion_cond<
+      : base_from_cancellation_state<ReadHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            ReadHandler>)(other)),
+        base_from_completion_cond<CompletionCondition>(
+          BOOST_ASIO_MOVE_CAST(base_from_completion_cond<
             CompletionCondition>)(other)),
         stream_(other.stream_),
         buffers_(BOOST_ASIO_MOVE_CAST(buffers_type)(other.buffers_)),
@@ -360,7 +366,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t max_size;
@@ -368,7 +374,7 @@ namespace detail
       {
         case 1:
         max_size = this->check_for_completion(ec, buffers_.total_consumed());
-        do
+        for (;;)
         {
           {
             BOOST_ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_read"));
@@ -380,9 +386,18 @@ namespace detail
           if ((!ec && bytes_transferred == 0) || buffers_.empty())
             break;
           max_size = this->check_for_completion(ec, buffers_.total_consumed());
-        } while (max_size > 0);
+          if (max_size == 0)
+            break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = error::operation_aborted;
+            break;
+          }
+        }
 
-        handler_(ec, buffers_.total_consumed());
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(
+            static_cast<const boost::system::error_code&>(ec),
+            static_cast<const std::size_t&>(buffers_.total_consumed()));
       }
     }
 
@@ -523,42 +538,22 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncReadStream, typename MutableBufferSequence,
-    typename MutableBufferIterator, typename CompletionCondition,
-    typename ReadHandler, typename Allocator>
-struct associated_allocator<
-    detail::read_op<AsyncReadStream, MutableBufferSequence,
-      MutableBufferIterator, CompletionCondition, ReadHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(
-      const detail::read_op<AsyncReadStream, MutableBufferSequence,
-        MutableBufferIterator, CompletionCondition, ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncReadStream, typename MutableBufferSequence,
+template <template <typename, typename> class Associator,
+    typename AsyncReadStream, typename MutableBufferSequence,
     typename MutableBufferIterator, typename CompletionCondition,
-    typename ReadHandler, typename Executor>
-struct associated_executor<
+    typename ReadHandler, typename DefaultCandidate>
+struct associator<Associator,
     detail::read_op<AsyncReadStream, MutableBufferSequence,
       MutableBufferIterator, CompletionCondition, ReadHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::read_op<AsyncReadStream, MutableBufferSequence,
         MutableBufferIterator, CompletionCondition, ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -567,37 +562,37 @@ struct associated_executor<
 template <typename AsyncReadStream,
     typename MutableBufferSequence, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_mutable_buffer_sequence<MutableBufferSequence>::value
     >::type)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
-      detail::initiate_async_read_buffer_sequence<AsyncReadStream>(s), handler,
+      detail::initiate_async_read_buffer_sequence<AsyncReadStream>(s), token,
       buffers, BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
 template <typename AsyncReadStream, typename MutableBufferSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_mutable_buffer_sequence<MutableBufferSequence>::value
     >::type)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_read_buffer_sequence<AsyncReadStream>(s),
-      handler, buffers, transfer_all());
+      token, buffers, transfer_all());
 }
 
 #if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
@@ -607,15 +602,17 @@ namespace detail
   template <typename AsyncReadStream, typename DynamicBuffer_v1,
       typename CompletionCondition, typename ReadHandler>
   class read_dynbuf_v1_op
-    : detail::base_from_completion_cond<CompletionCondition>
+    : public base_from_cancellation_state<ReadHandler>,
+      base_from_completion_cond<CompletionCondition>
   {
   public:
     template <typename BufferSequence>
     read_dynbuf_v1_op(AsyncReadStream& stream,
         BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         CompletionCondition& completion_condition, ReadHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
+      : base_from_cancellation_state<ReadHandler>(
+          handler, enable_partial_cancellation()),
+        base_from_completion_cond<CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         start_(0),
@@ -626,7 +623,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_dynbuf_v1_op(const read_dynbuf_v1_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
+      : base_from_cancellation_state<ReadHandler>(other),
+        base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
         start_(other.start_),
@@ -636,8 +634,11 @@ namespace detail
     }
 
     read_dynbuf_v1_op(read_dynbuf_v1_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(
-          BOOST_ASIO_MOVE_CAST(detail::base_from_completion_cond<
+      : base_from_cancellation_state<ReadHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            ReadHandler>)(other)),
+        base_from_completion_cond<CompletionCondition>(
+          BOOST_ASIO_MOVE_CAST(base_from_completion_cond<
             CompletionCondition>)(other)),
         stream_(other.stream_),
         buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(other.buffers_)),
@@ -648,7 +649,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t max_size, bytes_available;
@@ -679,9 +680,16 @@ namespace detail
                   buffers_.max_size() - buffers_.size()));
           if ((!ec && bytes_transferred == 0) || bytes_available == 0)
             break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = error::operation_aborted;
+            break;
+          }
         }
 
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(
+            static_cast<const boost::system::error_code&>(ec),
+            static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
@@ -806,40 +814,22 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename CompletionCondition, typename ReadHandler, typename Allocator>
-struct associated_allocator<
-    detail::read_dynbuf_v1_op<AsyncReadStream,
-      DynamicBuffer_v1, CompletionCondition, ReadHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(
-      const detail::read_dynbuf_v1_op<AsyncReadStream,
-        DynamicBuffer_v1, CompletionCondition, ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename CompletionCondition, typename ReadHandler, typename Executor>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+    typename AsyncReadStream, typename DynamicBuffer_v1,
+    typename CompletionCondition, typename ReadHandler,
+    typename DefaultCandidate>
+struct associator<Associator,
     detail::read_dynbuf_v1_op<AsyncReadStream,
       DynamicBuffer_v1, CompletionCondition, ReadHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::read_dynbuf_v1_op<AsyncReadStream,
         DynamicBuffer_v1, CompletionCondition, ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -847,12 +837,12 @@ struct associated_executor<
 
 template <typename AsyncReadStream, typename DynamicBuffer_v1,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value
     >::type,
@@ -862,19 +852,19 @@ async_read(AsyncReadStream& s,
 {
   return async_read(s,
       BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
-      transfer_all(), BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+      transfer_all(), BOOST_ASIO_MOVE_CAST(ReadToken)(token));
 }
 
 template <typename AsyncReadStream,
     typename DynamicBuffer_v1, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value
     >::type,
@@ -882,10 +872,10 @@ async_read(AsyncReadStream& s,
       !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value
     >::type)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_read_dynbuf_v1<AsyncReadStream>(s),
-      handler, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
+      token, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
       BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
@@ -894,29 +884,29 @@ async_read(AsyncReadStream& s,
 
 template <typename AsyncReadStream, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    BOOST_ASIO_MOVE_ARG(ReadToken) token)
 {
   return async_read(s, basic_streambuf_ref<Allocator>(b),
-      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+      BOOST_ASIO_MOVE_CAST(ReadToken)(token));
 }
 
 template <typename AsyncReadStream,
     typename Allocator, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    BOOST_ASIO_MOVE_ARG(ReadToken) token)
 {
   return async_read(s, basic_streambuf_ref<Allocator>(b),
       BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition),
-      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+      BOOST_ASIO_MOVE_CAST(ReadToken)(token));
 }
 
 #endif // !defined(BOOST_ASIO_NO_IOSTREAM)
@@ -928,15 +918,17 @@ namespace detail
   template <typename AsyncReadStream, typename DynamicBuffer_v2,
       typename CompletionCondition, typename ReadHandler>
   class read_dynbuf_v2_op
-    : detail::base_from_completion_cond<CompletionCondition>
+    : public base_from_cancellation_state<ReadHandler>,
+      base_from_completion_cond<CompletionCondition>
   {
   public:
     template <typename BufferSequence>
     read_dynbuf_v2_op(AsyncReadStream& stream,
         BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         CompletionCondition& completion_condition, ReadHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
+      : base_from_cancellation_state<ReadHandler>(
+          handler, enable_partial_cancellation()),
+        base_from_completion_cond<CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         start_(0),
@@ -948,7 +940,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_dynbuf_v2_op(const read_dynbuf_v2_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
+      : base_from_cancellation_state<ReadHandler>(other),
+        base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
         start_(other.start_),
@@ -959,8 +952,11 @@ namespace detail
     }
 
     read_dynbuf_v2_op(read_dynbuf_v2_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(
-          BOOST_ASIO_MOVE_CAST(detail::base_from_completion_cond<
+      : base_from_cancellation_state<ReadHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            ReadHandler>)(other)),
+        base_from_completion_cond<CompletionCondition>(
+          BOOST_ASIO_MOVE_CAST(base_from_completion_cond<
             CompletionCondition>)(other)),
         stream_(other.stream_),
         buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(other.buffers_)),
@@ -972,7 +968,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t max_size, pos;
@@ -1005,9 +1001,16 @@ namespace detail
                   buffers_.max_size() - buffers_.size()));
           if ((!ec && bytes_transferred == 0) || bytes_available_ == 0)
             break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = error::operation_aborted;
+            break;
+          }
         }
 
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(
+            static_cast<const boost::system::error_code&>(ec),
+            static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
@@ -1133,40 +1136,22 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename CompletionCondition, typename ReadHandler, typename Allocator>
-struct associated_allocator<
+template <template <typename, typename> class Associator,
+    typename AsyncReadStream, typename DynamicBuffer_v2,
+    typename CompletionCondition, typename ReadHandler,
+    typename DefaultCandidate>
+struct associator<Associator,
     detail::read_dynbuf_v2_op<AsyncReadStream,
       DynamicBuffer_v2, CompletionCondition, ReadHandler>,
-    Allocator>
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(
-      const detail::read_dynbuf_v2_op<AsyncReadStream,
-        DynamicBuffer_v2, CompletionCondition, ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename CompletionCondition, typename ReadHandler, typename Executor>
-struct associated_executor<
-    detail::read_dynbuf_v2_op<AsyncReadStream,
-      DynamicBuffer_v2, CompletionCondition, ReadHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
-{
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::read_dynbuf_v2_op<AsyncReadStream,
         DynamicBuffer_v2, CompletionCondition, ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -1174,37 +1159,37 @@ struct associated_executor<
 
 template <typename AsyncReadStream, typename DynamicBuffer_v2,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
     >::type)
 {
   return async_read(s,
       BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
-      transfer_all(), BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+      transfer_all(), BOOST_ASIO_MOVE_CAST(ReadToken)(token));
 }
 
 template <typename AsyncReadStream,
     typename DynamicBuffer_v2, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
     >::type)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_read_dynbuf_v2<AsyncReadStream>(s),
-      handler, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
+      token, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
       BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
diff --git a/boost/asio/impl/read_at.hpp b/boost/asio/impl/read_at.hpp
index 64f19530510781eeb58a5a203df0bb243a87238e..a41ec76c99588a9ca09d87859cb1e9c9af1081fa 100644
--- a/boost/asio/impl/read_at.hpp
+++ b/boost/asio/impl/read_at.hpp
@@ -2,7 +2,7 @@
 // impl/read_at.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,11 +16,11 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <algorithm>
-#include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associator.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/completion_condition.hpp>
 #include <boost/asio/detail/array_fwd.hpp>
+#include <boost/asio/detail/base_from_cancellation_state.hpp>
 #include <boost/asio/detail/base_from_completion_cond.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/consuming_buffers.hpp>
@@ -177,14 +177,16 @@ namespace detail
       typename MutableBufferSequence, typename MutableBufferIterator,
       typename CompletionCondition, typename ReadHandler>
   class read_at_op
-    : detail::base_from_completion_cond<CompletionCondition>
+    : public base_from_cancellation_state<ReadHandler>,
+      base_from_completion_cond<CompletionCondition>
   {
   public:
     read_at_op(AsyncRandomAccessReadDevice& device,
         uint64_t offset, const MutableBufferSequence& buffers,
         CompletionCondition& completion_condition, ReadHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
+      : base_from_cancellation_state<ReadHandler>(
+          handler, enable_partial_cancellation()),
+        base_from_completion_cond<CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffers_(buffers),
@@ -195,7 +197,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_at_op(const read_at_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
+      : base_from_cancellation_state<ReadHandler>(other),
+        base_from_completion_cond<CompletionCondition>(other),
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
@@ -205,8 +208,11 @@ namespace detail
     }
 
     read_at_op(read_at_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(
-          BOOST_ASIO_MOVE_CAST(detail::base_from_completion_cond<
+      : base_from_cancellation_state<ReadHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            ReadHandler>)(other)),
+        base_from_completion_cond<CompletionCondition>(
+          BOOST_ASIO_MOVE_CAST(base_from_completion_cond<
             CompletionCondition>)(other)),
         device_(other.device_),
         offset_(other.offset_),
@@ -217,7 +223,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t max_size;
@@ -225,7 +231,7 @@ namespace detail
       {
         case 1:
         max_size = this->check_for_completion(ec, buffers_.total_consumed());
-        do
+        for (;;)
         {
           {
             BOOST_ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_read_at"));
@@ -238,9 +244,18 @@ namespace detail
           if ((!ec && bytes_transferred == 0) || buffers_.empty())
             break;
           max_size = this->check_for_completion(ec, buffers_.total_consumed());
-        } while (max_size > 0);
+          if (max_size == 0)
+            break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = boost::asio::error::operation_aborted;
+            break;
+          }
+        }
 
-        handler_(ec, buffers_.total_consumed());
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(
+            static_cast<const boost::system::error_code&>(ec),
+            static_cast<const std::size_t&>(buffers_.total_consumed()));
       }
     }
 
@@ -384,44 +399,23 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncRandomAccessReadDevice,
-    typename MutableBufferSequence, typename MutableBufferIterator,
-    typename CompletionCondition, typename ReadHandler, typename Allocator>
-struct associated_allocator<
-    detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
-    MutableBufferIterator, CompletionCondition, ReadHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(
-      const detail::read_at_op<AsyncRandomAccessReadDevice,
-      MutableBufferSequence, MutableBufferIterator,
-      CompletionCondition, ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncRandomAccessReadDevice,
-    typename MutableBufferSequence, typename MutableBufferIterator,
-    typename CompletionCondition, typename ReadHandler, typename Executor>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+    typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
+    typename MutableBufferIterator, typename CompletionCondition,
+    typename ReadHandler, typename DefaultCandidate>
+struct associator<Associator,
     detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
-    MutableBufferIterator, CompletionCondition, ReadHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
+      MutableBufferIterator, CompletionCondition, ReadHandler>,
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::read_at_op<AsyncRandomAccessReadDevice,
-      MutableBufferSequence, MutableBufferIterator,
-      CompletionCondition, ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+        MutableBufferSequence, MutableBufferIterator,
+        CompletionCondition, ReadHandler>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -430,36 +424,36 @@ struct associated_executor<
 template <typename AsyncRandomAccessReadDevice,
     typename MutableBufferSequence, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    BOOST_ASIO_MOVE_ARG(ReadToken) token)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_read_at_buffer_sequence<
         AsyncRandomAccessReadDevice>(d),
-      handler, offset, buffers,
+      token, offset, buffers,
       BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
 template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, const MutableBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    BOOST_ASIO_MOVE_ARG(ReadToken) token)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_read_at_buffer_sequence<
         AsyncRandomAccessReadDevice>(d),
-      handler, offset, buffers, transfer_all());
+      token, offset, buffers, transfer_all());
 }
 
 #if !defined(BOOST_ASIO_NO_EXTENSIONS)
@@ -470,14 +464,16 @@ namespace detail
   template <typename AsyncRandomAccessReadDevice, typename Allocator,
       typename CompletionCondition, typename ReadHandler>
   class read_at_streambuf_op
-    : detail::base_from_completion_cond<CompletionCondition>
+    : public base_from_cancellation_state<ReadHandler>,
+      base_from_completion_cond<CompletionCondition>
   {
   public:
     read_at_streambuf_op(AsyncRandomAccessReadDevice& device,
         uint64_t offset, basic_streambuf<Allocator>& streambuf,
         CompletionCondition& completion_condition, ReadHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
+      : base_from_cancellation_state<ReadHandler>(
+          handler, enable_partial_cancellation()),
+        base_from_completion_cond<CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         streambuf_(streambuf),
@@ -489,7 +485,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_at_streambuf_op(const read_at_streambuf_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
+      : base_from_cancellation_state<ReadHandler>(other),
+        base_from_completion_cond<CompletionCondition>(other),
         device_(other.device_),
         offset_(other.offset_),
         streambuf_(other.streambuf_),
@@ -500,8 +497,11 @@ namespace detail
     }
 
     read_at_streambuf_op(read_at_streambuf_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(
-          BOOST_ASIO_MOVE_CAST(detail::base_from_completion_cond<
+      : base_from_cancellation_state<ReadHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            ReadHandler>)(other)),
+        base_from_completion_cond<CompletionCondition>(
+          BOOST_ASIO_MOVE_CAST(base_from_completion_cond<
             CompletionCondition>)(other)),
         device_(other.device_),
         offset_(other.offset_),
@@ -513,7 +513,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t max_size, bytes_available;
@@ -537,9 +537,16 @@ namespace detail
           bytes_available = read_size_helper(streambuf_, max_size);
           if ((!ec && bytes_transferred == 0) || bytes_available == 0)
             break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = boost::asio::error::operation_aborted;
+            break;
+          }
         }
 
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(
+            static_cast<const boost::system::error_code&>(ec),
+            static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
@@ -663,40 +670,22 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncRandomAccessReadDevice, typename Allocator,
-    typename CompletionCondition, typename ReadHandler, typename Allocator1>
-struct associated_allocator<
-    detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
-      Allocator, CompletionCondition, ReadHandler>,
-    Allocator1>
-{
-  typedef typename associated_allocator<ReadHandler, Allocator1>::type type;
-
-  static type get(
-      const detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
-        Allocator, CompletionCondition, ReadHandler>& h,
-      const Allocator1& a = Allocator1()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator1>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncRandomAccessReadDevice, typename Executor,
-    typename CompletionCondition, typename ReadHandler, typename Executor1>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+    typename AsyncRandomAccessReadDevice, typename Executor,
+    typename CompletionCondition, typename ReadHandler,
+    typename DefaultCandidate>
+struct associator<Associator,
     detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
       Executor, CompletionCondition, ReadHandler>,
-    Executor1>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<ReadHandler, Executor1>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
         Executor, CompletionCondition, ReadHandler>& h,
-      const Executor1& ex = Executor1()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor1>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -705,34 +694,34 @@ struct associated_executor<
 template <typename AsyncRandomAccessReadDevice,
     typename Allocator, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    BOOST_ASIO_MOVE_ARG(ReadToken) token)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_read_at_streambuf<AsyncRandomAccessReadDevice>(d),
-      handler, offset, &b,
+      token, offset, &b,
       BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
 template <typename AsyncRandomAccessReadDevice, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    BOOST_ASIO_MOVE_ARG(ReadToken) token)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_read_at_streambuf<AsyncRandomAccessReadDevice>(d),
-      handler, offset, &b, transfer_all());
+      token, offset, &b, transfer_all());
 }
 
 #endif // !defined(BOOST_ASIO_NO_IOSTREAM)
diff --git a/boost/asio/impl/read_until.hpp b/boost/asio/impl/read_until.hpp
index 2b0185816f7853c965d44193dbc38935f6f365e6..249f42c116e32b55b2ec255e91f7ab4a76420d3d 100644
--- a/boost/asio/impl/read_until.hpp
+++ b/boost/asio/impl/read_until.hpp
@@ -2,7 +2,7 @@
 // impl/read_until.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,10 +19,10 @@
 #include <string>
 #include <vector>
 #include <utility>
-#include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associator.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/buffers_iterator.hpp>
+#include <boost/asio/detail/base_from_cancellation_state.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
@@ -806,13 +806,16 @@ namespace detail
   template <typename AsyncReadStream,
       typename DynamicBuffer_v1, typename ReadHandler>
   class read_until_delim_op_v1
+    : public base_from_cancellation_state<ReadHandler>
   {
   public:
     template <typename BufferSequence>
     read_until_delim_op_v1(AsyncReadStream& stream,
         BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         char delim, ReadHandler& handler)
-      : stream_(stream),
+      : base_from_cancellation_state<ReadHandler>(
+          handler, enable_partial_cancellation()),
+        stream_(stream),
         buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         delim_(delim),
         start_(0),
@@ -823,7 +826,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_delim_op_v1(const read_until_delim_op_v1& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(other),
+        stream_(other.stream_),
         buffers_(other.buffers_),
         delim_(other.delim_),
         start_(other.start_),
@@ -833,7 +837,10 @@ namespace detail
     }
 
     read_until_delim_op_v1(read_until_delim_op_v1&& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            ReadHandler>)(other)),
+        stream_(other.stream_),
         buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(other.buffers_)),
         delim_(other.delim_),
         start_(other.start_),
@@ -843,7 +850,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
@@ -907,6 +914,11 @@ namespace detail
           buffers_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = error::operation_aborted;
+            break;
+          }
         }
 
         const boost::system::error_code result_ec =
@@ -917,7 +929,7 @@ namespace detail
           (ec || search_position_ == not_found)
           ? 0 : search_position_;
 
-        handler_(result_ec, result_n);
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(result_ec, result_n);
       }
     }
 
@@ -1039,40 +1051,21 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename ReadHandler, typename Allocator>
-struct associated_allocator<
-    detail::read_until_delim_op_v1<AsyncReadStream,
-      DynamicBuffer_v1, ReadHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(
-      const detail::read_until_delim_op_v1<AsyncReadStream,
-        DynamicBuffer_v1, ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename ReadHandler, typename Executor>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+    typename AsyncReadStream, typename DynamicBuffer_v1,
+    typename ReadHandler, typename DefaultCandidate>
+struct associator<Associator,
     detail::read_until_delim_op_v1<AsyncReadStream,
       DynamicBuffer_v1, ReadHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::read_until_delim_op_v1<AsyncReadStream,
         DynamicBuffer_v1, ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -1080,12 +1073,12 @@ struct associated_executor<
 
 template <typename AsyncReadStream, typename DynamicBuffer_v1,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
-    char delim, BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    char delim, BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value
     >::type,
@@ -1093,10 +1086,10 @@ async_read_until(AsyncReadStream& s,
       !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value
     >::type)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_read_until_delim_v1<AsyncReadStream>(s),
-      handler, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers), delim);
+      token, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers), delim);
 }
 
 namespace detail
@@ -1104,13 +1097,16 @@ namespace detail
   template <typename AsyncReadStream,
       typename DynamicBuffer_v1, typename ReadHandler>
   class read_until_delim_string_op_v1
+    : public base_from_cancellation_state<ReadHandler>
   {
   public:
     template <typename BufferSequence>
     read_until_delim_string_op_v1(AsyncReadStream& stream,
         BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         const std::string& delim, ReadHandler& handler)
-      : stream_(stream),
+      : base_from_cancellation_state<ReadHandler>(
+          handler, enable_partial_cancellation()),
+        stream_(stream),
         buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         delim_(delim),
         start_(0),
@@ -1121,7 +1117,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_delim_string_op_v1(const read_until_delim_string_op_v1& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(other),
+        stream_(other.stream_),
         buffers_(other.buffers_),
         delim_(other.delim_),
         start_(other.start_),
@@ -1131,7 +1128,10 @@ namespace detail
     }
 
     read_until_delim_string_op_v1(read_until_delim_string_op_v1&& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            ReadHandler>)(other)),
+        stream_(other.stream_),
         buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(other.buffers_)),
         delim_(BOOST_ASIO_MOVE_CAST(std::string)(other.delim_)),
         start_(other.start_),
@@ -1141,7 +1141,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
@@ -1216,6 +1216,11 @@ namespace detail
           buffers_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = error::operation_aborted;
+            break;
+          }
         }
 
         const boost::system::error_code result_ec =
@@ -1226,7 +1231,7 @@ namespace detail
           (ec || search_position_ == not_found)
           ? 0 : search_position_;
 
-        handler_(result_ec, result_n);
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(result_ec, result_n);
       }
     }
 
@@ -1348,40 +1353,21 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename ReadHandler, typename Allocator>
-struct associated_allocator<
-    detail::read_until_delim_string_op_v1<AsyncReadStream,
-      DynamicBuffer_v1, ReadHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(
-      const detail::read_until_delim_string_op_v1<AsyncReadStream,
-        DynamicBuffer_v1, ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename ReadHandler, typename Executor>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+    typename AsyncReadStream, typename DynamicBuffer_v1,
+    typename ReadHandler, typename DefaultCandidate>
+struct associator<Associator,
     detail::read_until_delim_string_op_v1<AsyncReadStream,
       DynamicBuffer_v1, ReadHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::read_until_delim_string_op_v1<AsyncReadStream,
         DynamicBuffer_v1, ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -1389,13 +1375,13 @@ struct associated_executor<
 
 template <typename AsyncReadStream, typename DynamicBuffer_v1,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
     BOOST_ASIO_STRING_VIEW_PARAM delim,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value
     >::type,
@@ -1403,10 +1389,10 @@ async_read_until(AsyncReadStream& s,
       !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value
     >::type)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_read_until_delim_string_v1<AsyncReadStream>(s),
-      handler, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
+      token, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
       static_cast<std::string>(delim));
 }
 
@@ -1418,13 +1404,16 @@ namespace detail
   template <typename AsyncReadStream, typename DynamicBuffer_v1,
       typename RegEx, typename ReadHandler>
   class read_until_expr_op_v1
+    : public base_from_cancellation_state<ReadHandler>
   {
   public:
     template <typename BufferSequence>
     read_until_expr_op_v1(AsyncReadStream& stream,
         BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         const boost::regex& expr, ReadHandler& handler)
-      : stream_(stream),
+      : base_from_cancellation_state<ReadHandler>(
+          handler, enable_partial_cancellation()),
+        stream_(stream),
         buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         expr_(expr),
         start_(0),
@@ -1435,7 +1424,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_expr_op_v1(const read_until_expr_op_v1& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(other),
+        stream_(other.stream_),
         buffers_(other.buffers_),
         expr_(other.expr_),
         start_(other.start_),
@@ -1445,7 +1435,10 @@ namespace detail
     }
 
     read_until_expr_op_v1(read_until_expr_op_v1&& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            ReadHandler>)(other)),
+        stream_(other.stream_),
         buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(other.buffers_)),
         expr_(other.expr_),
         start_(other.start_),
@@ -1455,7 +1448,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
@@ -1533,6 +1526,11 @@ namespace detail
           buffers_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = error::operation_aborted;
+            break;
+          }
         }
 
         const boost::system::error_code result_ec =
@@ -1543,7 +1541,7 @@ namespace detail
           (ec || search_position_ == not_found)
           ? 0 : search_position_;
 
-        handler_(result_ec, result_n);
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(result_ec, result_n);
       }
     }
 
@@ -1664,40 +1662,21 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename RegEx, typename ReadHandler, typename Allocator>
-struct associated_allocator<
-    detail::read_until_expr_op_v1<AsyncReadStream,
-      DynamicBuffer_v1, RegEx, ReadHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(
-      const detail::read_until_expr_op_v1<AsyncReadStream,
-        DynamicBuffer_v1, RegEx, ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename RegEx, typename ReadHandler, typename Executor>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+    typename AsyncReadStream, typename DynamicBuffer_v1,
+    typename RegEx, typename ReadHandler, typename DefaultCandidate>
+struct associator<Associator,
     detail::read_until_expr_op_v1<AsyncReadStream,
       DynamicBuffer_v1, RegEx, ReadHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::read_until_expr_op_v1<AsyncReadStream,
         DynamicBuffer_v1, RegEx, ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -1705,13 +1684,13 @@ struct associated_executor<
 
 template <typename AsyncReadStream, typename DynamicBuffer_v1,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
     const boost::regex& expr,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value
     >::type,
@@ -1719,10 +1698,10 @@ async_read_until(AsyncReadStream& s,
       !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value
     >::type)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_read_until_expr_v1<AsyncReadStream>(s),
-      handler, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers), expr);
+      token, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers), expr);
 }
 
 #endif // defined(BOOST_ASIO_HAS_BOOST_REGEX)
@@ -1732,13 +1711,16 @@ namespace detail
   template <typename AsyncReadStream, typename DynamicBuffer_v1,
       typename MatchCondition, typename ReadHandler>
   class read_until_match_op_v1
+    : public base_from_cancellation_state<ReadHandler>
   {
   public:
     template <typename BufferSequence>
     read_until_match_op_v1(AsyncReadStream& stream,
         BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         MatchCondition match_condition, ReadHandler& handler)
-      : stream_(stream),
+      : base_from_cancellation_state<ReadHandler>(
+          handler, enable_partial_cancellation()),
+        stream_(stream),
         buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         match_condition_(match_condition),
         start_(0),
@@ -1749,7 +1731,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_match_op_v1(const read_until_match_op_v1& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(other),
+        stream_(other.stream_),
         buffers_(other.buffers_),
         match_condition_(other.match_condition_),
         start_(other.start_),
@@ -1759,7 +1742,10 @@ namespace detail
     }
 
     read_until_match_op_v1(read_until_match_op_v1&& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            ReadHandler>)(other)),
+        stream_(other.stream_),
         buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(other.buffers_)),
         match_condition_(other.match_condition_),
         start_(other.start_),
@@ -1769,7 +1755,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
@@ -1843,6 +1829,11 @@ namespace detail
           buffers_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = error::operation_aborted;
+            break;
+          }
         }
 
         const boost::system::error_code result_ec =
@@ -1853,7 +1844,7 @@ namespace detail
           (ec || search_position_ == not_found)
           ? 0 : search_position_;
 
-        handler_(result_ec, result_n);
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(result_ec, result_n);
       }
     }
 
@@ -1978,40 +1969,21 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename MatchCondition, typename ReadHandler, typename Allocator>
-struct associated_allocator<
-    detail::read_until_match_op_v1<AsyncReadStream,
-      DynamicBuffer_v1, MatchCondition, ReadHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(
-      const detail::read_until_match_op_v1<AsyncReadStream,
-        DynamicBuffer_v1, MatchCondition, ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename MatchCondition, typename ReadHandler, typename Executor>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+    typename AsyncReadStream, typename DynamicBuffer_v1,
+    typename MatchCondition, typename ReadHandler, typename DefaultCandidate>
+struct associator<Associator,
     detail::read_until_match_op_v1<AsyncReadStream,
       DynamicBuffer_v1, MatchCondition, ReadHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::read_until_match_op_v1<AsyncReadStream,
         DynamicBuffer_v1, MatchCondition, ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -2020,12 +1992,12 @@ struct associated_executor<
 template <typename AsyncReadStream,
     typename DynamicBuffer_v1, typename MatchCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
-    MatchCondition match_condition, BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    MatchCondition match_condition, BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_match_condition<MatchCondition>::value
     >::type,
@@ -2036,9 +2008,9 @@ async_read_until(AsyncReadStream& s,
       !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value
     >::type)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
-      detail::initiate_async_read_until_match_v1<AsyncReadStream>(s), handler,
+      detail::initiate_async_read_until_match_v1<AsyncReadStream>(s), token,
       BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers), match_condition);
 }
 
@@ -2046,60 +2018,60 @@ async_read_until(AsyncReadStream& s,
 
 template <typename AsyncReadStream, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
-    char delim, BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    char delim, BOOST_ASIO_MOVE_ARG(ReadToken) token)
 {
   return async_read_until(s, basic_streambuf_ref<Allocator>(b),
-      delim, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+      delim, BOOST_ASIO_MOVE_CAST(ReadToken)(token));
 }
 
 template <typename AsyncReadStream, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     BOOST_ASIO_STRING_VIEW_PARAM delim,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    BOOST_ASIO_MOVE_ARG(ReadToken) token)
 {
   return async_read_until(s, basic_streambuf_ref<Allocator>(b),
-      delim, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+      delim, BOOST_ASIO_MOVE_CAST(ReadToken)(token));
 }
 
 #if defined(BOOST_ASIO_HAS_BOOST_REGEX)
 
 template <typename AsyncReadStream, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    BOOST_ASIO_MOVE_ARG(ReadToken) token)
 {
   return async_read_until(s, basic_streambuf_ref<Allocator>(b),
-      expr, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+      expr, BOOST_ASIO_MOVE_CAST(ReadToken)(token));
 }
 
 #endif // defined(BOOST_ASIO_HAS_BOOST_REGEX)
 
 template <typename AsyncReadStream, typename Allocator, typename MatchCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
-    MatchCondition match_condition, BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    MatchCondition match_condition, BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<is_match_condition<MatchCondition>::value>::type)
 {
   return async_read_until(s, basic_streambuf_ref<Allocator>(b),
-      match_condition, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+      match_condition, BOOST_ASIO_MOVE_CAST(ReadToken)(token));
 }
 
 #endif // !defined(BOOST_ASIO_NO_IOSTREAM)
@@ -2111,13 +2083,16 @@ namespace detail
   template <typename AsyncReadStream,
       typename DynamicBuffer_v2, typename ReadHandler>
   class read_until_delim_op_v2
+    : public base_from_cancellation_state<ReadHandler>
   {
   public:
     template <typename BufferSequence>
     read_until_delim_op_v2(AsyncReadStream& stream,
         BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         char delim, ReadHandler& handler)
-      : stream_(stream),
+      : base_from_cancellation_state<ReadHandler>(
+          handler, enable_partial_cancellation()),
+        stream_(stream),
         buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         delim_(delim),
         start_(0),
@@ -2129,7 +2104,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_delim_op_v2(const read_until_delim_op_v2& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(other),
+        stream_(other.stream_),
         buffers_(other.buffers_),
         delim_(other.delim_),
         start_(other.start_),
@@ -2140,7 +2116,10 @@ namespace detail
     }
 
     read_until_delim_op_v2(read_until_delim_op_v2&& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            ReadHandler>)(other)),
+        stream_(other.stream_),
         buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(other.buffers_)),
         delim_(other.delim_),
         start_(other.start_),
@@ -2151,7 +2130,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
@@ -2219,6 +2198,11 @@ namespace detail
           buffers_.shrink(bytes_to_read_ - bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = error::operation_aborted;
+            break;
+          }
         }
 
         const boost::system::error_code result_ec =
@@ -2229,7 +2213,7 @@ namespace detail
           (ec || search_position_ == not_found)
           ? 0 : search_position_;
 
-        handler_(result_ec, result_n);
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(result_ec, result_n);
       }
     }
 
@@ -2351,40 +2335,21 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename ReadHandler, typename Allocator>
-struct associated_allocator<
-    detail::read_until_delim_op_v2<AsyncReadStream,
-      DynamicBuffer_v2, ReadHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(
-      const detail::read_until_delim_op_v2<AsyncReadStream,
-        DynamicBuffer_v2, ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename ReadHandler, typename Executor>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+    typename AsyncReadStream, typename DynamicBuffer_v2,
+    typename ReadHandler, typename DefaultCandidate>
+struct associator<Associator,
     detail::read_until_delim_op_v2<AsyncReadStream,
       DynamicBuffer_v2, ReadHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::read_until_delim_op_v2<AsyncReadStream,
         DynamicBuffer_v2, ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -2392,19 +2357,19 @@ struct associated_executor<
 
 template <typename AsyncReadStream, typename DynamicBuffer_v2,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
-    char delim, BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    char delim, BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
     >::type)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_read_until_delim_v2<AsyncReadStream>(s),
-      handler, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers), delim);
+      token, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers), delim);
 }
 
 namespace detail
@@ -2412,13 +2377,16 @@ namespace detail
   template <typename AsyncReadStream,
       typename DynamicBuffer_v2, typename ReadHandler>
   class read_until_delim_string_op_v2
+    : public base_from_cancellation_state<ReadHandler>
   {
   public:
     template <typename BufferSequence>
     read_until_delim_string_op_v2(AsyncReadStream& stream,
         BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         const std::string& delim, ReadHandler& handler)
-      : stream_(stream),
+      : base_from_cancellation_state<ReadHandler>(
+          handler, enable_partial_cancellation()),
+        stream_(stream),
         buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         delim_(delim),
         start_(0),
@@ -2430,7 +2398,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_delim_string_op_v2(const read_until_delim_string_op_v2& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(other),
+        stream_(other.stream_),
         buffers_(other.buffers_),
         delim_(other.delim_),
         start_(other.start_),
@@ -2441,7 +2410,10 @@ namespace detail
     }
 
     read_until_delim_string_op_v2(read_until_delim_string_op_v2&& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            ReadHandler>)(other)),
+        stream_(other.stream_),
         buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(other.buffers_)),
         delim_(BOOST_ASIO_MOVE_CAST(std::string)(other.delim_)),
         start_(other.start_),
@@ -2452,7 +2424,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
@@ -2531,6 +2503,11 @@ namespace detail
           buffers_.shrink(bytes_to_read_ - bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = error::operation_aborted;
+            break;
+          }
         }
 
         const boost::system::error_code result_ec =
@@ -2541,7 +2518,7 @@ namespace detail
           (ec || search_position_ == not_found)
           ? 0 : search_position_;
 
-        handler_(result_ec, result_n);
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(result_ec, result_n);
       }
     }
 
@@ -2664,40 +2641,21 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename ReadHandler, typename Allocator>
-struct associated_allocator<
-    detail::read_until_delim_string_op_v2<AsyncReadStream,
-      DynamicBuffer_v2, ReadHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(
-      const detail::read_until_delim_string_op_v2<AsyncReadStream,
-        DynamicBuffer_v2, ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename ReadHandler, typename Executor>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+    typename AsyncReadStream, typename DynamicBuffer_v2,
+    typename ReadHandler, typename DefaultCandidate>
+struct associator<Associator,
     detail::read_until_delim_string_op_v2<AsyncReadStream,
       DynamicBuffer_v2, ReadHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::read_until_delim_string_op_v2<AsyncReadStream,
         DynamicBuffer_v2, ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -2706,20 +2664,20 @@ struct associated_executor<
 template <typename AsyncReadStream,
     typename DynamicBuffer_v2,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     DynamicBuffer_v2 buffers, BOOST_ASIO_STRING_VIEW_PARAM delim,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
     >::type)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_read_until_delim_string_v2<AsyncReadStream>(s),
-      handler, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
+      token, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
       static_cast<std::string>(delim));
 }
 
@@ -2731,13 +2689,16 @@ namespace detail
   template <typename AsyncReadStream, typename DynamicBuffer_v2,
       typename RegEx, typename ReadHandler>
   class read_until_expr_op_v2
+    : public base_from_cancellation_state<ReadHandler>
   {
   public:
     template <typename BufferSequence>
     read_until_expr_op_v2(AsyncReadStream& stream,
         BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         const boost::regex& expr, ReadHandler& handler)
-      : stream_(stream),
+      : base_from_cancellation_state<ReadHandler>(
+          handler, enable_partial_cancellation()),
+        stream_(stream),
         buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         expr_(expr),
         start_(0),
@@ -2749,7 +2710,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_expr_op_v2(const read_until_expr_op_v2& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(other),
+        stream_(other.stream_),
         buffers_(other.buffers_),
         expr_(other.expr_),
         start_(other.start_),
@@ -2760,7 +2722,10 @@ namespace detail
     }
 
     read_until_expr_op_v2(read_until_expr_op_v2&& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            ReadHandler>)(other)),
+        stream_(other.stream_),
         buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(other.buffers_)),
         expr_(other.expr_),
         start_(other.start_),
@@ -2771,7 +2736,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
@@ -2853,6 +2818,11 @@ namespace detail
           buffers_.shrink(bytes_to_read_ - bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = error::operation_aborted;
+            break;
+          }
         }
 
         const boost::system::error_code result_ec =
@@ -2863,7 +2833,7 @@ namespace detail
           (ec || search_position_ == not_found)
           ? 0 : search_position_;
 
-        handler_(result_ec, result_n);
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(result_ec, result_n);
       }
     }
 
@@ -2986,40 +2956,21 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename RegEx, typename ReadHandler, typename Allocator>
-struct associated_allocator<
-    detail::read_until_expr_op_v2<AsyncReadStream,
-      DynamicBuffer_v2, RegEx, ReadHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(
-      const detail::read_until_expr_op_v2<AsyncReadStream,
-        DynamicBuffer_v2, RegEx, ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename RegEx, typename ReadHandler, typename Executor>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+    typename AsyncReadStream, typename DynamicBuffer_v2,
+    typename RegEx, typename ReadHandler, typename DefaultCandidate>
+struct associator<Associator,
     detail::read_until_expr_op_v2<AsyncReadStream,
       DynamicBuffer_v2, RegEx, ReadHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::read_until_expr_op_v2<AsyncReadStream,
         DynamicBuffer_v2, RegEx, ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -3027,19 +2978,19 @@ struct associated_executor<
 
 template <typename AsyncReadStream, typename DynamicBuffer_v2,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
-    const boost::regex& expr, BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    const boost::regex& expr, BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
     >::type)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_read_until_expr_v2<AsyncReadStream>(s),
-      handler, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers), expr);
+      token, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers), expr);
 }
 
 #endif // defined(BOOST_ASIO_HAS_BOOST_REGEX)
@@ -3049,13 +3000,16 @@ namespace detail
   template <typename AsyncReadStream, typename DynamicBuffer_v2,
       typename MatchCondition, typename ReadHandler>
   class read_until_match_op_v2
+    : public base_from_cancellation_state<ReadHandler>
   {
   public:
     template <typename BufferSequence>
     read_until_match_op_v2(AsyncReadStream& stream,
         BOOST_ASIO_MOVE_ARG(BufferSequence) buffers,
         MatchCondition match_condition, ReadHandler& handler)
-      : stream_(stream),
+      : base_from_cancellation_state<ReadHandler>(
+          handler, enable_partial_cancellation()),
+        stream_(stream),
         buffers_(BOOST_ASIO_MOVE_CAST(BufferSequence)(buffers)),
         match_condition_(match_condition),
         start_(0),
@@ -3067,7 +3021,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_match_op_v2(const read_until_match_op_v2& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(other),
+        stream_(other.stream_),
         buffers_(other.buffers_),
         match_condition_(other.match_condition_),
         start_(other.start_),
@@ -3078,7 +3033,10 @@ namespace detail
     }
 
     read_until_match_op_v2(read_until_match_op_v2&& other)
-      : stream_(other.stream_),
+      : base_from_cancellation_state<ReadHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            ReadHandler>)(other)),
+        stream_(other.stream_),
         buffers_(BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(other.buffers_)),
         match_condition_(other.match_condition_),
         start_(other.start_),
@@ -3089,7 +3047,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
@@ -3167,6 +3125,11 @@ namespace detail
           buffers_.shrink(bytes_to_read_ - bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = error::operation_aborted;
+            break;
+          }
         }
 
         const boost::system::error_code result_ec =
@@ -3177,7 +3140,7 @@ namespace detail
           (ec || search_position_ == not_found)
           ? 0 : search_position_;
 
-        handler_(result_ec, result_n);
+        BOOST_ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(result_ec, result_n);
       }
     }
 
@@ -3303,40 +3266,21 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename MatchCondition, typename ReadHandler, typename Allocator>
-struct associated_allocator<
-    detail::read_until_match_op_v2<AsyncReadStream,
-      DynamicBuffer_v2, MatchCondition, ReadHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<ReadHandler, Allocator>::type type;
-
-  static type get(
-      const detail::read_until_match_op_v2<AsyncReadStream,
-        DynamicBuffer_v2, MatchCondition, ReadHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename MatchCondition, typename ReadHandler, typename Executor>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+    typename AsyncReadStream, typename DynamicBuffer_v2,
+    typename MatchCondition, typename ReadHandler, typename DefaultCandidate>
+struct associator<Associator,
     detail::read_until_match_op_v2<AsyncReadStream,
       DynamicBuffer_v2, MatchCondition, ReadHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<ReadHandler, Executor>
+    DefaultCandidate>
+  : Associator<ReadHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<ReadHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<ReadHandler, DefaultCandidate>::type get(
       const detail::read_until_match_op_v2<AsyncReadStream,
         DynamicBuffer_v2, MatchCondition, ReadHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -3345,11 +3289,11 @@ struct associated_executor<
 template <typename AsyncReadStream,
     typename DynamicBuffer_v2, typename MatchCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
-    MatchCondition match_condition, BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    MatchCondition match_condition, BOOST_ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_match_condition<MatchCondition>::value
     >::type,
@@ -3357,9 +3301,9 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
     >::type)
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (boost::system::error_code, std::size_t)>(
-      detail::initiate_async_read_until_match_v2<AsyncReadStream>(s), handler,
+      detail::initiate_async_read_until_match_v2<AsyncReadStream>(s), token,
       BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers), match_condition);
 }
 
diff --git a/boost/asio/impl/redirect_error.hpp b/boost/asio/impl/redirect_error.hpp
index d3f3286aec61bf597efc1705782ee187f667e1f0..ea886a961f70c3d1f18ccaf7af66cf93ecc265fb 100644
--- a/boost/asio/impl/redirect_error.hpp
+++ b/boost/asio/impl/redirect_error.hpp
@@ -2,7 +2,7 @@
 // impl/redirect_error.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,8 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/asio/associated_executor.hpp>
-#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
@@ -56,7 +55,7 @@ public:
 
   void operator()()
   {
-    handler_();
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)();
   }
 
 #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
@@ -67,7 +66,8 @@ public:
   >::type
   operator()(BOOST_ASIO_MOVE_ARG(Arg) arg, BOOST_ASIO_MOVE_ARG(Args)... args)
   {
-    handler_(BOOST_ASIO_MOVE_CAST(Arg)(arg),
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        BOOST_ASIO_MOVE_CAST(Arg)(arg),
         BOOST_ASIO_MOVE_CAST(Args)(args)...);
   }
 
@@ -76,7 +76,8 @@ public:
       BOOST_ASIO_MOVE_ARG(Args)... args)
   {
     ec_ = ec;
-    handler_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        BOOST_ASIO_MOVE_CAST(Args)(args)...);
   }
 
 #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
@@ -87,13 +88,14 @@ public:
   >::type
   operator()(BOOST_ASIO_MOVE_ARG(Arg) arg)
   {
-    handler_(BOOST_ASIO_MOVE_CAST(Arg)(arg));
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
+        BOOST_ASIO_MOVE_CAST(Arg)(arg));
   }
 
   void operator()(const boost::system::error_code& ec)
   {
     ec_ = ec;
-    handler_();
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)();
   }
 
 #define BOOST_ASIO_PRIVATE_REDIRECT_ERROR_DEF(n) \
@@ -103,7 +105,8 @@ public:
   >::type \
   operator()(BOOST_ASIO_MOVE_ARG(Arg) arg, BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
   { \
-    handler_(BOOST_ASIO_MOVE_CAST(Arg)(arg), \
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)( \
+        BOOST_ASIO_MOVE_CAST(Arg)(arg), \
         BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
   } \
   \
@@ -112,7 +115,8 @@ public:
       BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
   { \
     ec_ = ec; \
-    handler_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)( \
+        BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
   } \
   /**/
   BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_REDIRECT_ERROR_DEF)
@@ -203,6 +207,78 @@ struct redirect_error_signature<R(const boost::system::error_code&, Args...)>
   typedef R type(Args...);
 };
 
+# if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+template <typename R, typename... Args>
+struct redirect_error_signature<R(boost::system::error_code, Args...) &>
+{
+  typedef R type(Args...) &;
+};
+
+template <typename R, typename... Args>
+struct redirect_error_signature<R(const boost::system::error_code&, Args...) &>
+{
+  typedef R type(Args...) &;
+};
+
+template <typename R, typename... Args>
+struct redirect_error_signature<R(boost::system::error_code, Args...) &&>
+{
+  typedef R type(Args...) &&;
+};
+
+template <typename R, typename... Args>
+struct redirect_error_signature<R(const boost::system::error_code&, Args...) &&>
+{
+  typedef R type(Args...) &&;
+};
+
+#  if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
+template <typename R, typename... Args>
+struct redirect_error_signature<
+  R(boost::system::error_code, Args...) noexcept>
+{
+  typedef R type(Args...) & noexcept;
+};
+
+template <typename R, typename... Args>
+struct redirect_error_signature<
+  R(const boost::system::error_code&, Args...) noexcept>
+{
+  typedef R type(Args...) & noexcept;
+};
+
+template <typename R, typename... Args>
+struct redirect_error_signature<
+  R(boost::system::error_code, Args...) & noexcept>
+{
+  typedef R type(Args...) & noexcept;
+};
+
+template <typename R, typename... Args>
+struct redirect_error_signature<
+  R(const boost::system::error_code&, Args...) & noexcept>
+{
+  typedef R type(Args...) & noexcept;
+};
+
+template <typename R, typename... Args>
+struct redirect_error_signature<
+  R(boost::system::error_code, Args...) && noexcept>
+{
+  typedef R type(Args...) && noexcept;
+};
+
+template <typename R, typename... Args>
+struct redirect_error_signature<
+  R(const boost::system::error_code&, Args...) && noexcept>
+{
+  typedef R type(Args...) && noexcept;
+};
+
+#  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>
@@ -235,6 +311,161 @@ struct redirect_error_signature<R(const boost::system::error_code&)>
   BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_REDIRECT_ERROR_DEF)
 #undef BOOST_ASIO_PRIVATE_REDIRECT_ERROR_DEF
 
+# if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+
+template <typename R>
+struct redirect_error_signature<R(boost::system::error_code) &>
+{
+  typedef R type() &;
+};
+
+template <typename R>
+struct redirect_error_signature<R(const boost::system::error_code&) &>
+{
+  typedef R type() &;
+};
+
+template <typename R>
+struct redirect_error_signature<R(boost::system::error_code) &&>
+{
+  typedef R type() &&;
+};
+
+template <typename R>
+struct redirect_error_signature<R(const boost::system::error_code&) &&>
+{
+  typedef R type() &&;
+};
+
+#define BOOST_ASIO_PRIVATE_REDIRECT_ERROR_DEF(n) \
+  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  struct redirect_error_signature< \
+      R(boost::system::error_code, BOOST_ASIO_VARIADIC_TARGS(n)) &> \
+  { \
+    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)) &; \
+  }; \
+  \
+  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  struct redirect_error_signature< \
+      R(const boost::system::error_code&, BOOST_ASIO_VARIADIC_TARGS(n)) &> \
+  { \
+    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)) &; \
+  }; \
+  \
+  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  struct redirect_error_signature< \
+      R(boost::system::error_code, BOOST_ASIO_VARIADIC_TARGS(n)) &&> \
+  { \
+    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)) &&; \
+  }; \
+  \
+  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  struct redirect_error_signature< \
+      R(const boost::system::error_code&, BOOST_ASIO_VARIADIC_TARGS(n)) &&> \
+  { \
+    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)) &&; \
+  }; \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_REDIRECT_ERROR_DEF)
+#undef BOOST_ASIO_PRIVATE_REDIRECT_ERROR_DEF
+
+#  if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
+template <typename R>
+struct redirect_error_signature<
+  R(boost::system::error_code) noexcept>
+{
+  typedef R type() noexcept;
+};
+
+template <typename R>
+struct redirect_error_signature<
+  R(const boost::system::error_code&) noexcept>
+{
+  typedef R type() noexcept;
+};
+
+template <typename R>
+struct redirect_error_signature<
+  R(boost::system::error_code) & noexcept>
+{
+  typedef R type() & noexcept;
+};
+
+template <typename R>
+struct redirect_error_signature<
+  R(const boost::system::error_code&) & noexcept>
+{
+  typedef R type() & noexcept;
+};
+
+template <typename R>
+struct redirect_error_signature<
+  R(boost::system::error_code) && noexcept>
+{
+  typedef R type() && noexcept;
+};
+
+template <typename R>
+struct redirect_error_signature<
+  R(const boost::system::error_code&) && noexcept>
+{
+  typedef R type() && noexcept;
+};
+
+#define BOOST_ASIO_PRIVATE_REDIRECT_ERROR_DEF(n) \
+  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  struct redirect_error_signature< \
+      R(boost::system::error_code, BOOST_ASIO_VARIADIC_TARGS(n)) noexcept> \
+  { \
+    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)) noexcept; \
+  }; \
+  \
+  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  struct redirect_error_signature< \
+      R(const boost::system::error_code&, \
+        BOOST_ASIO_VARIADIC_TARGS(n)) noexcept> \
+  { \
+    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)) noexcept; \
+  }; \
+  \
+  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  struct redirect_error_signature< \
+      R(boost::system::error_code, \
+        BOOST_ASIO_VARIADIC_TARGS(n)) & noexcept> \
+  { \
+    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)) & noexcept; \
+  }; \
+  \
+  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  struct redirect_error_signature< \
+      R(const boost::system::error_code&, \
+        BOOST_ASIO_VARIADIC_TARGS(n)) & noexcept> \
+  { \
+    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)) & noexcept; \
+  }; \
+  \
+  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  struct redirect_error_signature< \
+      R(boost::system::error_code, \
+        BOOST_ASIO_VARIADIC_TARGS(n)) && noexcept> \
+  { \
+    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)) && noexcept; \
+  }; \
+  \
+  template <typename R, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  struct redirect_error_signature< \
+      R(const boost::system::error_code&, \
+        BOOST_ASIO_VARIADIC_TARGS(n)) && noexcept> \
+  { \
+    typedef R type(BOOST_ASIO_VARIADIC_TARGS(n)) && noexcept; \
+  }; \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_REDIRECT_ERROR_DEF)
+#undef BOOST_ASIO_PRIVATE_REDIRECT_ERROR_DEF
+
+#  endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+# endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
 #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 } // namespace detail
@@ -356,30 +587,17 @@ struct async_result<redirect_error_t<CompletionToken>, Signature>
 #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 };
 
-template <typename Handler, typename Executor>
-struct associated_executor<detail::redirect_error_handler<Handler>, Executor>
-  : detail::associated_executor_forwarding_base<Handler, Executor>
+template <template <typename, typename> class Associator,
+    typename Handler, typename DefaultCandidate>
+struct associator<Associator,
+    detail::redirect_error_handler<Handler>, DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_executor<Handler, Executor>::type type;
-
-  static type get(
-      const detail::redirect_error_handler<Handler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
-  }
-};
-
-template <typename Handler, typename Allocator>
-struct associated_allocator<detail::redirect_error_handler<Handler>, Allocator>
-{
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(
+  static typename Associator<Handler, DefaultCandidate>::type get(
       const detail::redirect_error_handler<Handler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
diff --git a/boost/asio/impl/serial_port_base.hpp b/boost/asio/impl/serial_port_base.hpp
index c42a083ceed07b5f0c4b826749f54872da623a12..bffec99c3704c2caa605fe70ffc124f9dd2f132e 100644
--- a/boost/asio/impl/serial_port_base.hpp
+++ b/boost/asio/impl/serial_port_base.hpp
@@ -2,7 +2,7 @@
 // impl/serial_port_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/impl/serial_port_base.ipp b/boost/asio/impl/serial_port_base.ipp
index 6657c8ace4ba466387dcfe406b0547175534e138..d80b327fb8e1923506e422da0d7b29d365aa0223 100644
--- a/boost/asio/impl/serial_port_base.ipp
+++ b/boost/asio/impl/serial_port_base.ipp
@@ -2,7 +2,7 @@
 // impl/serial_port_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/impl/spawn.hpp b/boost/asio/impl/spawn.hpp
index fdbe28d5be37febe2b8f305c777d492230bc0554..43778cf898d938eaf7150848421ee0753982bf72 100644
--- a/boost/asio/impl/spawn.hpp
+++ b/boost/asio/impl/spawn.hpp
@@ -2,7 +2,7 @@
 // impl/spawn.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -296,28 +296,18 @@ public:
   }
 };
 
-template <typename Handler, typename T, typename Allocator>
-struct associated_allocator<detail::coro_handler<Handler, T>, Allocator>
+template <template <typename, typename> class Associator,
+    typename Handler, typename T, typename DefaultCandidate>
+struct associator<Associator,
+    detail::coro_handler<Handler, T>,
+    DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(const detail::coro_handler<Handler, T>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename Handler, typename T, typename Executor>
-struct associated_executor<detail::coro_handler<Handler, T>, Executor>
-  : detail::associated_executor_forwarding_base<Handler, Executor>
-{
-  typedef typename associated_executor<Handler, Executor>::type type;
-
-  static type get(const detail::coro_handler<Handler, T>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const detail::coro_handler<Handler, T>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -355,7 +345,7 @@ namespace detail {
 
       (data->function_)(yield);
       if (data->call_handler_)
-        (data->handler_)();
+        BOOST_ASIO_MOVE_OR_LVALUE(Handler)(data->handler_)();
     }
 
     shared_ptr<spawn_data<Handler, Function> > data_;
diff --git a/boost/asio/impl/src.hpp b/boost/asio/impl/src.hpp
index c7e8e386dd0b310feaf95d7d525d9676789410e7..2df92d9987544e8ed3bd7dccaefadf0722adcdfb 100644
--- a/boost/asio/impl/src.hpp
+++ b/boost/asio/impl/src.hpp
@@ -2,7 +2,7 @@
 // impl/src.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,6 +19,9 @@
 # error Do not compile Asio library source with BOOST_ASIO_HEADER_ONLY defined
 #endif
 
+#include <boost/asio/impl/any_io_executor.ipp>
+#include <boost/asio/impl/cancellation_signal.ipp>
+#include <boost/asio/impl/connect_pipe.ipp>
 #include <boost/asio/impl/error.ipp>
 #include <boost/asio/impl/execution_context.ipp>
 #include <boost/asio/impl/executor.ipp>
@@ -34,15 +37,19 @@
 #include <boost/asio/detail/impl/epoll_reactor.ipp>
 #include <boost/asio/detail/impl/eventfd_select_interrupter.ipp>
 #include <boost/asio/detail/impl/handler_tracking.ipp>
+#include <boost/asio/detail/impl/io_uring_descriptor_service.ipp>
+#include <boost/asio/detail/impl/io_uring_file_service.ipp>
+#include <boost/asio/detail/impl/io_uring_socket_service_base.ipp>
+#include <boost/asio/detail/impl/io_uring_service.ipp>
 #include <boost/asio/detail/impl/kqueue_reactor.ipp>
 #include <boost/asio/detail/impl/null_event.ipp>
 #include <boost/asio/detail/impl/pipe_select_interrupter.ipp>
 #include <boost/asio/detail/impl/posix_event.ipp>
 #include <boost/asio/detail/impl/posix_mutex.ipp>
+#include <boost/asio/detail/impl/posix_serial_port_service.ipp>
 #include <boost/asio/detail/impl/posix_thread.ipp>
 #include <boost/asio/detail/impl/posix_tss_ptr.ipp>
 #include <boost/asio/detail/impl/reactive_descriptor_service.ipp>
-#include <boost/asio/detail/impl/reactive_serial_port_service.ipp>
 #include <boost/asio/detail/impl/reactive_socket_service_base.ipp>
 #include <boost/asio/detail/impl/resolver_service_base.ipp>
 #include <boost/asio/detail/impl/scheduler.ipp>
@@ -57,6 +64,7 @@
 #include <boost/asio/detail/impl/throw_error.ipp>
 #include <boost/asio/detail/impl/timer_queue_ptime.ipp>
 #include <boost/asio/detail/impl/timer_queue_set.ipp>
+#include <boost/asio/detail/impl/win_iocp_file_service.ipp>
 #include <boost/asio/detail/impl/win_iocp_handle_service.ipp>
 #include <boost/asio/detail/impl/win_iocp_io_context.ipp>
 #include <boost/asio/detail/impl/win_iocp_serial_port_service.ipp>
@@ -72,6 +80,7 @@
 #include <boost/asio/detail/impl/winsock_init.ipp>
 #include <boost/asio/execution/impl/bad_executor.ipp>
 #include <boost/asio/execution/impl/receiver_invocation_error.ipp>
+#include <boost/asio/experimental/impl/channel_error.ipp>
 #include <boost/asio/generic/detail/impl/endpoint.ipp>
 #include <boost/asio/ip/impl/address.ipp>
 #include <boost/asio/ip/impl/address_v4.ipp>
diff --git a/boost/asio/impl/system_context.hpp b/boost/asio/impl/system_context.hpp
index 653113e98588879cd23bab5be2079bdfc3e75c56..084251a7e4c577279bd608950dc9eab875ffea53 100644
--- a/boost/asio/impl/system_context.hpp
+++ b/boost/asio/impl/system_context.hpp
@@ -2,7 +2,7 @@
 // impl/system_context.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/system_context.ipp b/boost/asio/impl/system_context.ipp
index 98dd0bfe72da401464cc55687ab24dd6cedf30d2..46b72a834682a37a0be8be50593581b085f891e6 100644
--- a/boost/asio/impl/system_context.ipp
+++ b/boost/asio/impl/system_context.ipp
@@ -2,7 +2,7 @@
 // impl/system_context.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/system_executor.hpp b/boost/asio/impl/system_executor.hpp
index 2cffce741b3ad714eb6ba308f54081c9e3b2482b..1a40ef922ec14d1277cbe12cff1564056806fd85 100644
--- a/boost/asio/impl/system_executor.hpp
+++ b/boost/asio/impl/system_executor.hpp
@@ -2,7 +2,7 @@
 // impl/system_executor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/thread_pool.hpp b/boost/asio/impl/thread_pool.hpp
index fb2a5f3e9ab259cccc563153a85d83391c755ee6..ddda458aa13cdcac51a209d7016162ac3b1f2127 100644
--- a/boost/asio/impl/thread_pool.hpp
+++ b/boost/asio/impl/thread_pool.hpp
@@ -2,7 +2,7 @@
 // impl/thread_pool.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/thread_pool.ipp b/boost/asio/impl/thread_pool.ipp
index 0fdfdffc5dcf1d7015217d523a3e2a5347796e8e..644903689578753e078aa21eb4416f57e426902a 100644
--- a/boost/asio/impl/thread_pool.ipp
+++ b/boost/asio/impl/thread_pool.ipp
@@ -2,7 +2,7 @@
 // impl/thread_pool.ipp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/use_awaitable.hpp b/boost/asio/impl/use_awaitable.hpp
index 39a91ceae23336dbd537bf0b8074e68ab5ce07de..b0525283a5b4ebb09c74edacb888c3647bcdca39 100644
--- a/boost/asio/impl/use_awaitable.hpp
+++ b/boost/asio/impl/use_awaitable.hpp
@@ -2,7 +2,7 @@
 // impl/use_awaitable.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,7 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/async_result.hpp>
+#include <boost/asio/cancellation_signal.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -33,8 +34,9 @@ public:
   typedef awaitable<T, Executor> awaitable_type;
 
   // Construct from the entry point of a new thread of execution.
-  awaitable_handler_base(awaitable<void, Executor> a, const Executor& ex)
-    : awaitable_thread<Executor>(std::move(a), ex)
+  awaitable_handler_base(awaitable<awaitable_thread_entry_point, Executor> a,
+      const Executor& ex, cancellation_slot pcs, cancellation_state cs)
+    : awaitable_thread<Executor>(std::move(a), ex, pcs, cs)
   {
   }
 
@@ -47,7 +49,8 @@ public:
 protected:
   awaitable_frame<T, Executor>* frame() noexcept
   {
-    return static_cast<awaitable_frame<T, Executor>*>(this->top_of_stack_);
+    return static_cast<awaitable_frame<T, Executor>*>(
+        this->entry_point()->top_of_stack_);
   }
 };
 
@@ -65,6 +68,7 @@ public:
   {
     this->frame()->attach_thread(this);
     this->frame()->return_void();
+    this->frame()->clear_cancellation_slot();
     this->frame()->pop_frame();
     this->pump();
   }
@@ -84,6 +88,7 @@ public:
       this->frame()->set_error(ec);
     else
       this->frame()->return_void();
+    this->frame()->clear_cancellation_slot();
     this->frame()->pop_frame();
     this->pump();
   }
@@ -103,6 +108,7 @@ public:
       this->frame()->set_except(ex);
     else
       this->frame()->return_void();
+    this->frame()->clear_cancellation_slot();
     this->frame()->pop_frame();
     this->pump();
   }
@@ -120,6 +126,7 @@ public:
   {
     this->frame()->attach_thread(this);
     this->frame()->return_value(std::forward<Arg>(arg));
+    this->frame()->clear_cancellation_slot();
     this->frame()->pop_frame();
     this->pump();
   }
@@ -140,6 +147,7 @@ public:
       this->frame()->set_error(ec);
     else
       this->frame()->return_value(std::forward<Arg>(arg));
+    this->frame()->clear_cancellation_slot();
     this->frame()->pop_frame();
     this->pump();
   }
@@ -160,6 +168,7 @@ public:
       this->frame()->set_except(ex);
     else
       this->frame()->return_value(std::forward<Arg>(arg));
+    this->frame()->clear_cancellation_slot();
     this->frame()->pop_frame();
     this->pump();
   }
@@ -178,6 +187,7 @@ public:
   {
     this->frame()->attach_thread(this);
     this->frame()->return_values(std::forward<Args>(args)...);
+    this->frame()->clear_cancellation_slot();
     this->frame()->pop_frame();
     this->pump();
   }
@@ -199,6 +209,7 @@ public:
       this->frame()->set_error(ec);
     else
       this->frame()->return_values(std::forward<Args>(args)...);
+    this->frame()->clear_cancellation_slot();
     this->frame()->pop_frame();
     this->pump();
   }
@@ -220,6 +231,7 @@ public:
       this->frame()->set_except(ex);
     else
       this->frame()->return_values(std::forward<Args>(args)...);
+    this->frame()->clear_cancellation_slot();
     this->frame()->pop_frame();
     this->pump();
   }
@@ -251,17 +263,27 @@ public:
   typedef typename handler_type::awaitable_type return_type;
 
   template <typename Initiation, typename... InitArgs>
-  static return_type initiate(Initiation initiation,
-      use_awaitable_t<Executor> u, InitArgs... args)
+#if defined(__APPLE_CC__) && (__clang_major__ == 13)
+  __attribute__((noinline))
+#endif // defined(__APPLE_CC__) && (__clang_major__ == 13)
+  static handler_type* do_init(
+      detail::awaitable_frame_base<Executor>* frame, Initiation& initiation,
+      use_awaitable_t<Executor> u, InitArgs&... args)
   {
     (void)u;
+    BOOST_ASIO_HANDLER_LOCATION((u.file_name_, u.line_, u.function_name_));
+    handler_type handler(frame->detach_thread());
+    std::move(initiation)(std::move(handler), std::move(args)...);
+    return nullptr;
+  }
 
-    co_await [&](auto* frame)
+  template <typename Initiation, typename... InitArgs>
+  static return_type initiate(Initiation initiation,
+      use_awaitable_t<Executor> u, InitArgs... args)
+  {
+    co_await [&] (auto* frame)
       {
-        BOOST_ASIO_HANDLER_LOCATION((u.file_name_, u.line_, u.function_name_));
-        handler_type handler(frame->detach_thread());
-        std::move(initiation)(std::move(handler), std::move(args)...);
-        return static_cast<handler_type*>(nullptr);
+        return do_init(frame, initiation, u, args...);
       };
 
     for (;;) {} // Never reached.
diff --git a/boost/asio/impl/use_future.hpp b/boost/asio/impl/use_future.hpp
index dc5f0d03e2786cd4baf20b92f209a98bb5f78b4d..4e55d3ccb27ac25bcd72a3a23735f31c190084bc 100644
--- a/boost/asio/impl/use_future.hpp
+++ b/boost/asio/impl/use_future.hpp
@@ -2,7 +2,7 @@
 // impl/use_future.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/impl/write.hpp b/boost/asio/impl/write.hpp
index 848025b7c19cc1083b5a5f3c765dc4d701b1114c..d87e6bbf36a98957be572435c9f73b49c0c38ae4 100644
--- a/boost/asio/impl/write.hpp
+++ b/boost/asio/impl/write.hpp
@@ -2,7 +2,7 @@
 // impl/write.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,11 +15,11 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associator.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/completion_condition.hpp>
 #include <boost/asio/detail/array_fwd.hpp>
+#include <boost/asio/detail/base_from_cancellation_state.hpp>
 #include <boost/asio/detail/base_from_completion_cond.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/consuming_buffers.hpp>
@@ -289,13 +289,15 @@ namespace detail
       typename ConstBufferIterator, typename CompletionCondition,
       typename WriteHandler>
   class write_op
-    : detail::base_from_completion_cond<CompletionCondition>
+    : public base_from_cancellation_state<WriteHandler>,
+      base_from_completion_cond<CompletionCondition>
   {
   public:
     write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
         CompletionCondition& completion_condition, WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
+      : base_from_cancellation_state<WriteHandler>(
+          handler, enable_partial_cancellation()),
+        base_from_completion_cond<CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
         start_(0),
@@ -305,7 +307,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     write_op(const write_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
+      : base_from_cancellation_state<WriteHandler>(other),
+        base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
         start_(other.start_),
@@ -314,8 +317,11 @@ namespace detail
     }
 
     write_op(write_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(
-          BOOST_ASIO_MOVE_CAST(detail::base_from_completion_cond<
+      : base_from_cancellation_state<WriteHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            WriteHandler>)(other)),
+        base_from_completion_cond<CompletionCondition>(
+          BOOST_ASIO_MOVE_CAST(base_from_completion_cond<
             CompletionCondition>)(other)),
         stream_(other.stream_),
         buffers_(BOOST_ASIO_MOVE_CAST(buffers_type)(other.buffers_)),
@@ -325,7 +331,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t max_size;
@@ -333,7 +339,7 @@ namespace detail
       {
         case 1:
         max_size = this->check_for_completion(ec, buffers_.total_consumed());
-        do
+        for (;;)
         {
           {
             BOOST_ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_write"));
@@ -345,9 +351,18 @@ namespace detail
           if ((!ec && bytes_transferred == 0) || buffers_.empty())
             break;
           max_size = this->check_for_completion(ec, buffers_.total_consumed());
-        } while (max_size > 0);
+          if (max_size == 0)
+            break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = error::operation_aborted;
+            break;
+          }
+        }
 
-        handler_(ec, buffers_.total_consumed());
+        BOOST_ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(
+            static_cast<const boost::system::error_code&>(ec),
+            static_cast<const std::size_t&>(buffers_.total_consumed()));
       }
     }
 
@@ -488,42 +503,22 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncWriteStream, typename ConstBufferSequence,
+template <template <typename, typename> class Associator,
+    typename AsyncWriteStream, typename ConstBufferSequence,
     typename ConstBufferIterator, typename CompletionCondition,
-    typename WriteHandler, typename Allocator>
-struct associated_allocator<
+    typename WriteHandler, typename DefaultCandidate>
+struct associator<Associator,
     detail::write_op<AsyncWriteStream, ConstBufferSequence,
       ConstBufferIterator, CompletionCondition, WriteHandler>,
-    Allocator>
+    DefaultCandidate>
+  : Associator<WriteHandler, DefaultCandidate>
 {
-  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
-
-  static type get(
+  static typename Associator<WriteHandler, DefaultCandidate>::type get(
       const detail::write_op<AsyncWriteStream, ConstBufferSequence,
         ConstBufferIterator, CompletionCondition, WriteHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncWriteStream, typename ConstBufferSequence,
-    typename ConstBufferIterator, typename CompletionCondition,
-    typename WriteHandler, typename Executor>
-struct associated_executor<
-    detail::write_op<AsyncWriteStream, ConstBufferSequence,
-      ConstBufferIterator, CompletionCondition, WriteHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<WriteHandler, Executor>
-{
-  typedef typename associated_executor<WriteHandler, Executor>::type type;
-
-  static type get(
-      const detail::write_op<AsyncWriteStream, ConstBufferSequence,
-        ConstBufferIterator, CompletionCondition, WriteHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -532,38 +527,38 @@ struct associated_executor<
 template <typename AsyncWriteStream,
     typename ConstBufferSequence, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+    BOOST_ASIO_MOVE_ARG(WriteToken) token,
     typename constraint<
       is_const_buffer_sequence<ConstBufferSequence>::value
     >::type)
 {
-  return async_initiate<WriteHandler,
+  return async_initiate<WriteToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_write_buffer_sequence<AsyncWriteStream>(s),
-      handler, buffers,
+      token, buffers,
       BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
 template <typename AsyncWriteStream, typename ConstBufferSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+    BOOST_ASIO_MOVE_ARG(WriteToken) token,
     typename constraint<
       is_const_buffer_sequence<ConstBufferSequence>::value
     >::type)
 {
-  return async_initiate<WriteHandler,
+  return async_initiate<WriteToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_write_buffer_sequence<AsyncWriteStream>(s),
-      handler, buffers, transfer_all());
+      token, buffers, transfer_all());
 }
 
 #if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
@@ -618,7 +613,8 @@ namespace detail
             BOOST_ASIO_MOVE_CAST(write_dynbuf_v1_op)(*this));
         return; default:
         buffers_.consume(bytes_transferred);
-        handler_(ec, static_cast<const std::size_t&>(bytes_transferred));
+        BOOST_ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(ec,
+            static_cast<const std::size_t&>(bytes_transferred));
       }
     }
 
@@ -742,40 +738,22 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncWriteStream, typename DynamicBuffer_v1,
-    typename CompletionCondition, typename WriteHandler, typename Allocator>
-struct associated_allocator<
+template <template <typename, typename> class Associator,
+    typename AsyncWriteStream, typename DynamicBuffer_v1,
+    typename CompletionCondition, typename WriteHandler,
+    typename DefaultCandidate>
+struct associator<Associator,
     detail::write_dynbuf_v1_op<AsyncWriteStream,
       DynamicBuffer_v1, CompletionCondition, WriteHandler>,
-    Allocator>
+    DefaultCandidate>
+  : Associator<WriteHandler, DefaultCandidate>
 {
-  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
-
-  static type get(
+  static typename Associator<WriteHandler, DefaultCandidate>::type get(
       const detail::write_dynbuf_v1_op<AsyncWriteStream,
         DynamicBuffer_v1, CompletionCondition, WriteHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncWriteStream, typename DynamicBuffer_v1,
-    typename CompletionCondition, typename WriteHandler, typename Executor>
-struct associated_executor<
-    detail::write_dynbuf_v1_op<AsyncWriteStream,
-      DynamicBuffer_v1, CompletionCondition, WriteHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<WriteHandler, Executor>
-{
-  typedef typename associated_executor<WriteHandler, Executor>::type type;
-
-  static type get(
-      const detail::write_dynbuf_v1_op<AsyncWriteStream,
-        DynamicBuffer_v1, CompletionCondition, WriteHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -783,12 +761,12 @@ struct associated_executor<
 
 template <typename AsyncWriteStream, typename DynamicBuffer_v1,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+    BOOST_ASIO_MOVE_ARG(WriteToken) token,
     typename constraint<
       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value
     >::type,
@@ -798,19 +776,19 @@ async_write(AsyncWriteStream& s,
 {
   return async_write(s,
       BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
-      transfer_all(), BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+      transfer_all(), BOOST_ASIO_MOVE_CAST(WriteToken)(token));
 }
 
 template <typename AsyncWriteStream,
     typename DynamicBuffer_v1, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+    BOOST_ASIO_MOVE_ARG(WriteToken) token,
     typename constraint<
       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value
     >::type,
@@ -818,10 +796,10 @@ async_write(AsyncWriteStream& s,
       !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value
     >::type)
 {
-  return async_initiate<WriteHandler,
+  return async_initiate<WriteToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>(s),
-      handler, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
+      token, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
       BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
@@ -830,31 +808,31 @@ async_write(AsyncWriteStream& s,
 
 template <typename AsyncWriteStream, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    BOOST_ASIO_MOVE_ARG(WriteToken) token)
 {
   return async_write(s, basic_streambuf_ref<Allocator>(b),
-      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+      BOOST_ASIO_MOVE_CAST(WriteToken)(token));
 }
 
 template <typename AsyncWriteStream,
     typename Allocator, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    BOOST_ASIO_MOVE_ARG(WriteToken) token)
 {
   return async_write(s, basic_streambuf_ref<Allocator>(b),
       BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition),
-      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+      BOOST_ASIO_MOVE_CAST(WriteToken)(token));
 }
 
 #endif // !defined(BOOST_ASIO_NO_IOSTREAM)
@@ -911,7 +889,8 @@ namespace detail
             BOOST_ASIO_MOVE_CAST(write_dynbuf_v2_op)(*this));
         return; default:
         buffers_.consume(bytes_transferred);
-        handler_(ec, static_cast<const std::size_t&>(bytes_transferred));
+        BOOST_ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(ec,
+            static_cast<const std::size_t&>(bytes_transferred));
       }
     }
 
@@ -1035,40 +1014,45 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncWriteStream, typename DynamicBuffer_v2,
-    typename CompletionCondition, typename WriteHandler, typename Allocator>
-struct associated_allocator<
+template <template <typename, typename> class Associator,
+    typename AsyncWriteStream, typename DynamicBuffer_v2,
+    typename CompletionCondition, typename WriteHandler,
+    typename DefaultCandidate>
+struct associator<Associator,
     detail::write_dynbuf_v2_op<AsyncWriteStream,
       DynamicBuffer_v2, CompletionCondition, WriteHandler>,
-    Allocator>
+    DefaultCandidate>
+  : Associator<WriteHandler, DefaultCandidate>
 {
-  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
-
-  static type get(
+  static typename Associator<WriteHandler, DefaultCandidate>::type get(
       const detail::write_dynbuf_v2_op<AsyncWriteStream,
         DynamicBuffer_v2, CompletionCondition, WriteHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
+    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
 template <typename AsyncWriteStream, typename DynamicBuffer_v2,
-    typename CompletionCondition, typename WriteHandler, typename Executor>
-struct associated_executor<
+    typename CompletionCondition, typename WriteHandler,
+    typename CancellationSlot>
+struct associated_cancellation_slot<
     detail::write_dynbuf_v2_op<AsyncWriteStream,
       DynamicBuffer_v2, CompletionCondition, WriteHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<WriteHandler, Executor>
+    CancellationSlot>
+  : detail::associated_cancellation_slot_forwarding_base<
+      WriteHandler, CancellationSlot>
 {
-  typedef typename associated_executor<WriteHandler, Executor>::type type;
+  typedef typename associated_cancellation_slot<
+      WriteHandler, CancellationSlot>::type type;
 
   static type get(
       const detail::write_dynbuf_v2_op<AsyncWriteStream,
         DynamicBuffer_v2, CompletionCondition, WriteHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const CancellationSlot& s = CancellationSlot()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+    return associated_cancellation_slot<WriteHandler,
+        CancellationSlot>::get(h.handler_, s);
   }
 };
 
@@ -1076,37 +1060,37 @@ struct associated_executor<
 
 template <typename AsyncWriteStream, typename DynamicBuffer_v2,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+    BOOST_ASIO_MOVE_ARG(WriteToken) token,
     typename constraint<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
     >::type)
 {
   return async_write(s,
       BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
-      transfer_all(), BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+      transfer_all(), BOOST_ASIO_MOVE_CAST(WriteToken)(token));
 }
 
 template <typename AsyncWriteStream,
     typename DynamicBuffer_v2, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+    BOOST_ASIO_MOVE_ARG(WriteToken) token,
     typename constraint<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
     >::type)
 {
-  return async_initiate<WriteHandler,
+  return async_initiate<WriteToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_write_dynbuf_v2<AsyncWriteStream>(s),
-      handler, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
+      token, BOOST_ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
       BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
diff --git a/boost/asio/impl/write_at.hpp b/boost/asio/impl/write_at.hpp
index 32c5ee82da58c83ead6c772ad0c08055aaac202f..1e01cfd88d5bd76d4e2befec19d74c0ddf93edbc 100644
--- a/boost/asio/impl/write_at.hpp
+++ b/boost/asio/impl/write_at.hpp
@@ -2,7 +2,7 @@
 // impl/write_at.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,11 +15,11 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associator.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/completion_condition.hpp>
 #include <boost/asio/detail/array_fwd.hpp>
+#include <boost/asio/detail/base_from_cancellation_state.hpp>
 #include <boost/asio/detail/base_from_completion_cond.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/consuming_buffers.hpp>
@@ -162,14 +162,16 @@ namespace detail
       typename ConstBufferSequence, typename ConstBufferIterator,
       typename CompletionCondition, typename WriteHandler>
   class write_at_op
-    : detail::base_from_completion_cond<CompletionCondition>
+    : public base_from_cancellation_state<WriteHandler>,
+      base_from_completion_cond<CompletionCondition>
   {
   public:
     write_at_op(AsyncRandomAccessWriteDevice& device,
         uint64_t offset, const ConstBufferSequence& buffers,
         CompletionCondition& completion_condition, WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
+      : base_from_cancellation_state<WriteHandler>(
+          handler, enable_partial_cancellation()),
+        base_from_completion_cond<CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffers_(buffers),
@@ -180,7 +182,8 @@ namespace detail
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     write_at_op(const write_at_op& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
+      : base_from_cancellation_state<WriteHandler>(other),
+        base_from_completion_cond<CompletionCondition>(other),
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
@@ -190,8 +193,11 @@ namespace detail
     }
 
     write_at_op(write_at_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(
-          BOOST_ASIO_MOVE_CAST(detail::base_from_completion_cond<
+      : base_from_cancellation_state<WriteHandler>(
+          BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+            WriteHandler>)(other)),
+        base_from_completion_cond<CompletionCondition>(
+          BOOST_ASIO_MOVE_CAST(base_from_completion_cond<
             CompletionCondition>)(other)),
         device_(other.device_),
         offset_(other.offset_),
@@ -202,7 +208,7 @@ namespace detail
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
-    void operator()(const boost::system::error_code& ec,
+    void operator()(boost::system::error_code ec,
         std::size_t bytes_transferred, int start = 0)
     {
       std::size_t max_size;
@@ -210,7 +216,7 @@ namespace detail
       {
         case 1:
         max_size = this->check_for_completion(ec, buffers_.total_consumed());
-        do
+        for (;;)
         {
           {
             BOOST_ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_write_at"));
@@ -223,9 +229,18 @@ namespace detail
           if ((!ec && bytes_transferred == 0) || buffers_.empty())
             break;
           max_size = this->check_for_completion(ec, buffers_.total_consumed());
-        } while (max_size > 0);
+          if (max_size == 0)
+            break;
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec = boost::asio::error::operation_aborted;
+            break;
+          }
+        }
 
-        handler_(ec, buffers_.total_consumed());
+        BOOST_ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(
+            static_cast<const boost::system::error_code&>(ec),
+            static_cast<const std::size_t&>(buffers_.total_consumed()));
       }
     }
 
@@ -369,44 +384,23 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename AsyncRandomAccessWriteDevice,
-    typename ConstBufferSequence, typename ConstBufferIterator,
-    typename CompletionCondition, typename WriteHandler, typename Allocator>
-struct associated_allocator<
-    detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
-      ConstBufferIterator, CompletionCondition, WriteHandler>,
-    Allocator>
-{
-  typedef typename associated_allocator<WriteHandler, Allocator>::type type;
-
-  static type get(
-      const detail::write_at_op<AsyncRandomAccessWriteDevice,
-        ConstBufferSequence, ConstBufferIterator,
-        CompletionCondition, WriteHandler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename AsyncRandomAccessWriteDevice,
-    typename ConstBufferSequence, typename ConstBufferIterator,
-    typename CompletionCondition, typename WriteHandler, typename Executor>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+    typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+    typename ConstBufferIterator, typename CompletionCondition,
+    typename WriteHandler, typename DefaultCandidate>
+struct associator<Associator,
     detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
       ConstBufferIterator, CompletionCondition, WriteHandler>,
-    Executor>
-  : detail::associated_executor_forwarding_base<WriteHandler, Executor>
+    DefaultCandidate>
+  : Associator<WriteHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<WriteHandler, Executor>::type type;
-
-  static type get(
+  static typename Associator<WriteHandler, DefaultCandidate>::type get(
       const detail::write_at_op<AsyncRandomAccessWriteDevice,
         ConstBufferSequence, ConstBufferIterator,
         CompletionCondition, WriteHandler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -415,36 +409,36 @@ struct associated_executor<
 template <typename AsyncRandomAccessWriteDevice,
     typename ConstBufferSequence, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write_at(AsyncRandomAccessWriteDevice& d,
     uint64_t offset, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    BOOST_ASIO_MOVE_ARG(WriteToken) token)
 {
-  return async_initiate<WriteHandler,
+  return async_initiate<WriteToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_write_at_buffer_sequence<
         AsyncRandomAccessWriteDevice>(d),
-      handler, offset, buffers,
+      token, offset, buffers,
       BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
 template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write_at(AsyncRandomAccessWriteDevice& d,
     uint64_t offset, const ConstBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    BOOST_ASIO_MOVE_ARG(WriteToken) token)
 {
-  return async_initiate<WriteHandler,
+  return async_initiate<WriteToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_write_at_buffer_sequence<
         AsyncRandomAccessWriteDevice>(d),
-      handler, offset, buffers, transfer_all());
+      token, offset, buffers, transfer_all());
 }
 
 #if !defined(BOOST_ASIO_NO_EXTENSIONS)
@@ -482,7 +476,7 @@ namespace detail
         const std::size_t bytes_transferred)
     {
       streambuf_.consume(bytes_transferred);
-      handler_(ec, bytes_transferred);
+      BOOST_ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(ec, bytes_transferred);
     }
 
   //private:
@@ -589,34 +583,18 @@ namespace detail
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename Allocator, typename WriteHandler, typename Allocator1>
-struct associated_allocator<
-    detail::write_at_streambuf_op<Allocator, WriteHandler>,
-    Allocator1>
-{
-  typedef typename associated_allocator<WriteHandler, Allocator1>::type type;
-
-  static type get(
-      const detail::write_at_streambuf_op<Allocator, WriteHandler>& h,
-      const Allocator1& a = Allocator1()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<WriteHandler, Allocator1>::get(h.handler_, a);
-  }
-};
-
-template <typename Executor, typename WriteHandler, typename Executor1>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+    typename Executor, typename WriteHandler, typename DefaultCandidate>
+struct associator<Associator,
     detail::write_at_streambuf_op<Executor, WriteHandler>,
-    Executor1>
-  : detail::associated_executor_forwarding_base<WriteHandler, Executor>
+    DefaultCandidate>
+  : Associator<WriteHandler, DefaultCandidate>
 {
-  typedef typename associated_executor<WriteHandler, Executor1>::type type;
-
-  static type get(
+  static typename Associator<WriteHandler, DefaultCandidate>::type get(
       const detail::write_at_streambuf_op<Executor, WriteHandler>& h,
-      const Executor1& ex = Executor1()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<WriteHandler, Executor1>::get(h.handler_, ex);
+    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
@@ -625,36 +603,36 @@ struct associated_executor<
 template <typename AsyncRandomAccessWriteDevice,
     typename Allocator, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write_at(AsyncRandomAccessWriteDevice& d,
     uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    BOOST_ASIO_MOVE_ARG(WriteToken) token)
 {
-  return async_initiate<WriteHandler,
+  return async_initiate<WriteToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_write_at_streambuf<
         AsyncRandomAccessWriteDevice>(d),
-      handler, offset, &b,
+      token, offset, &b,
       BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write_at(AsyncRandomAccessWriteDevice& d,
     uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    BOOST_ASIO_MOVE_ARG(WriteToken) token)
 {
-  return async_initiate<WriteHandler,
+  return async_initiate<WriteToken,
     void (boost::system::error_code, std::size_t)>(
       detail::initiate_async_write_at_streambuf<
         AsyncRandomAccessWriteDevice>(d),
-      handler, offset, &b, transfer_all());
+      token, offset, &b, transfer_all());
 }
 
 #endif // !defined(BOOST_ASIO_NO_IOSTREAM)
diff --git a/boost/asio/io_context.hpp b/boost/asio/io_context.hpp
index 907da228a24151bc08b25a93ac1a9693ff8bcf38..2cf1e18d722ae5cc1e27f258e2a64c45526a51b3 100644
--- a/boost/asio/io_context.hpp
+++ b/boost/asio/io_context.hpp
@@ -2,7 +2,7 @@
 // io_context.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,6 +20,8 @@
 #include <stdexcept>
 #include <typeinfo>
 #include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/concurrency_hint.hpp>
+#include <boost/asio/detail/cstdint.hpp>
 #include <boost/asio/detail/wrapped_handler.hpp>
 #include <boost/system/error_code.hpp>
 #include <boost/asio/execution.hpp>
@@ -57,9 +59,10 @@ namespace detail {
 
   struct io_context_bits
   {
-    BOOST_ASIO_STATIC_CONSTEXPR(unsigned int, blocking_never = 1);
-    BOOST_ASIO_STATIC_CONSTEXPR(unsigned int, relationship_continuation = 2);
-    BOOST_ASIO_STATIC_CONSTEXPR(unsigned int, outstanding_work_tracked = 4);
+    BOOST_ASIO_STATIC_CONSTEXPR(uintptr_t, blocking_never = 1);
+    BOOST_ASIO_STATIC_CONSTEXPR(uintptr_t, relationship_continuation = 2);
+    BOOST_ASIO_STATIC_CONSTEXPR(uintptr_t, outstanding_work_tracked = 4);
+    BOOST_ASIO_STATIC_CONSTEXPR(uintptr_t, runtime_bits = 3);
   };
 } // namespace detail
 
@@ -219,10 +222,10 @@ private:
 #endif
 
 public:
-  template <typename Allocator, unsigned int Bits>
+  template <typename Allocator, uintptr_t Bits>
   class basic_executor_type;
 
-  template <typename Allocator, unsigned int Bits>
+  template <typename Allocator, uintptr_t Bits>
   friend class basic_executor_type;
 
   /// Executor used to submit functions to an io_context.
@@ -401,7 +404,7 @@ public:
   BOOST_ASIO_DECL count_type run_one();
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use non-error_code overlaod.) Run the io_context object's
+  /// (Deprecated: Use non-error_code overload.) Run the io_context object's
   /// event processing loop to execute at most one handler.
   /**
    * The run_one() function blocks until one handler has been dispatched, or
@@ -668,31 +671,30 @@ namespace detail {
 } // namespace detail
 
 /// Executor implementation type used to submit functions to an io_context.
-template <typename Allocator, unsigned int Bits>
-class io_context::basic_executor_type : detail::io_context_bits
+template <typename Allocator, uintptr_t Bits>
+class io_context::basic_executor_type :
+  detail::io_context_bits, Allocator
 {
 public:
   /// Copy constructor.
   basic_executor_type(
       const basic_executor_type& other) BOOST_ASIO_NOEXCEPT
-    : io_context_(other.io_context_),
-      allocator_(other.allocator_),
-      bits_(other.bits_)
+    : Allocator(static_cast<const Allocator&>(other)),
+      target_(other.target_)
   {
     if (Bits & outstanding_work_tracked)
-      if (io_context_)
-        io_context_->impl_.work_started();
+      if (context_ptr())
+        context_ptr()->impl_.work_started();
   }
 
 #if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
   /// Move constructor.
   basic_executor_type(basic_executor_type&& other) BOOST_ASIO_NOEXCEPT
-    : io_context_(other.io_context_),
-      allocator_(BOOST_ASIO_MOVE_CAST(Allocator)(other.allocator_)),
-      bits_(other.bits_)
+    : Allocator(BOOST_ASIO_MOVE_CAST(Allocator)(other)),
+      target_(other.target_)
   {
     if (Bits & outstanding_work_tracked)
-      other.io_context_ = 0;
+      other.target_ = 0;
   }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
@@ -700,8 +702,8 @@ public:
   ~basic_executor_type() BOOST_ASIO_NOEXCEPT
   {
     if (Bits & outstanding_work_tracked)
-      if (io_context_)
-        io_context_->impl_.work_finished();
+      if (context_ptr())
+        context_ptr()->impl_.work_finished();
   }
 
   /// Assignment operator.
@@ -716,8 +718,8 @@ public:
 
 #if !defined(GENERATING_DOCUMENTATION)
 private:
-  friend struct asio_require_fn::impl;
-  friend struct asio_prefer_fn::impl;
+  friend struct boost_asio_require_fn::impl;
+  friend struct boost_asio_prefer_fn::impl;
 #endif // !defined(GENERATING_DOCUMENTATION)
 
   /// Obtain an executor with the @c blocking.possibly property.
@@ -733,8 +735,8 @@ private:
   BOOST_ASIO_CONSTEXPR basic_executor_type require(
       execution::blocking_t::possibly_t) const
   {
-    return basic_executor_type(io_context_,
-        allocator_, bits_ & ~blocking_never);
+    return basic_executor_type(context_ptr(),
+        *this, bits() & ~blocking_never);
   }
 
   /// Obtain an executor with the @c blocking.never property.
@@ -750,8 +752,8 @@ private:
   BOOST_ASIO_CONSTEXPR basic_executor_type require(
       execution::blocking_t::never_t) const
   {
-    return basic_executor_type(io_context_,
-        allocator_, bits_ | blocking_never);
+    return basic_executor_type(context_ptr(),
+        *this, bits() | blocking_never);
   }
 
   /// Obtain an executor with the @c relationship.fork property.
@@ -767,8 +769,8 @@ private:
   BOOST_ASIO_CONSTEXPR basic_executor_type require(
       execution::relationship_t::fork_t) const
   {
-    return basic_executor_type(io_context_,
-        allocator_, bits_ & ~relationship_continuation);
+    return basic_executor_type(context_ptr(),
+        *this, bits() & ~relationship_continuation);
   }
 
   /// Obtain an executor with the @c relationship.continuation property.
@@ -784,8 +786,8 @@ private:
   BOOST_ASIO_CONSTEXPR basic_executor_type require(
       execution::relationship_t::continuation_t) const
   {
-    return basic_executor_type(io_context_,
-        allocator_, bits_ | relationship_continuation);
+    return basic_executor_type(context_ptr(),
+        *this, bits() | relationship_continuation);
   }
 
   /// Obtain an executor with the @c outstanding_work.tracked property.
@@ -803,7 +805,7 @@ private:
   require(execution::outstanding_work_t::tracked_t) const
   {
     return basic_executor_type<Allocator, Bits | outstanding_work_tracked>(
-        io_context_, allocator_, bits_);
+        context_ptr(), *this, bits());
   }
 
   /// Obtain an executor with the @c outstanding_work.untracked property.
@@ -821,7 +823,7 @@ private:
   require(execution::outstanding_work_t::untracked_t) const
   {
     return basic_executor_type<Allocator, Bits & ~outstanding_work_tracked>(
-        io_context_, allocator_, bits_);
+        context_ptr(), *this, bits());
   }
 
   /// Obtain an executor with the specified @c allocator property.
@@ -839,7 +841,7 @@ private:
   require(execution::allocator_t<OtherAllocator> a) const
   {
     return basic_executor_type<OtherAllocator, Bits>(
-        io_context_, a.value(), bits_);
+        context_ptr(), a.value(), bits());
   }
 
   /// Obtain an executor with the default @c allocator property.
@@ -856,12 +858,12 @@ private:
   require(execution::allocator_t<void>) const
   {
     return basic_executor_type<std::allocator<void>, Bits>(
-        io_context_, std::allocator<void>(), bits_);
+        context_ptr(), std::allocator<void>(), bits());
   }
 
 #if !defined(GENERATING_DOCUMENTATION)
 private:
-  friend struct asio_query_fn::impl;
+  friend struct boost_asio_query_fn::impl;
   friend struct boost::asio::execution::detail::mapping_t<0>;
   friend struct boost::asio::execution::detail::outstanding_work_t<0>;
 #endif // !defined(GENERATING_DOCUMENTATION)
@@ -895,7 +897,7 @@ private:
    */
   io_context& query(execution::context_t) const BOOST_ASIO_NOEXCEPT
   {
-    return *io_context_;
+    return *context_ptr();
   }
 
   /// Query the current value of the @c blocking property.
@@ -912,7 +914,7 @@ private:
   BOOST_ASIO_CONSTEXPR execution::blocking_t query(
       execution::blocking_t) const BOOST_ASIO_NOEXCEPT
   {
-    return (bits_ & blocking_never)
+    return (bits() & blocking_never)
       ? execution::blocking_t(execution::blocking.never)
       : execution::blocking_t(execution::blocking.possibly);
   }
@@ -931,7 +933,7 @@ private:
   BOOST_ASIO_CONSTEXPR execution::relationship_t query(
       execution::relationship_t) const BOOST_ASIO_NOEXCEPT
   {
-    return (bits_ & relationship_continuation)
+    return (bits() & relationship_continuation)
       ? execution::relationship_t(execution::relationship.continuation)
       : execution::relationship_t(execution::relationship.fork);
   }
@@ -969,7 +971,7 @@ private:
   BOOST_ASIO_CONSTEXPR Allocator query(
       execution::allocator_t<OtherAllocator>) const BOOST_ASIO_NOEXCEPT
   {
-    return allocator_;
+    return static_cast<const Allocator&>(*this);
   }
 
   /// Query the current value of the @c allocator property.
@@ -985,7 +987,7 @@ private:
   BOOST_ASIO_CONSTEXPR Allocator query(
       execution::allocator_t<void>) const BOOST_ASIO_NOEXCEPT
   {
-    return allocator_;
+    return static_cast<const Allocator&>(*this);
   }
 
 public:
@@ -1003,9 +1005,8 @@ public:
   friend bool operator==(const basic_executor_type& a,
       const basic_executor_type& b) BOOST_ASIO_NOEXCEPT
   {
-    return a.io_context_ == b.io_context_
-      && a.allocator_ == b.allocator_
-      && a.bits_ == b.bits_;
+    return a.target_ == b.target_
+      && static_cast<const Allocator&>(a) == static_cast<const Allocator&>(b);
   }
 
   /// Compare two executors for inequality.
@@ -1015,14 +1016,13 @@ public:
   friend bool operator!=(const basic_executor_type& a,
       const basic_executor_type& b) BOOST_ASIO_NOEXCEPT
   {
-    return a.io_context_ != b.io_context_
-      || a.allocator_ != b.allocator_
-      || a.bits_ != b.bits_;
+    return a.target_ != b.target_
+      || static_cast<const Allocator&>(a) != static_cast<const Allocator&>(b);
   }
 
 #if !defined(GENERATING_DOCUMENTATION)
 private:
-  friend struct asio_execution_execute_fn::impl;
+  friend struct boost_asio_execution_execute_fn::impl;
 #endif // !defined(GENERATING_DOCUMENTATION)
 
   /// Execution function.
@@ -1117,38 +1117,40 @@ public:
 
 private:
   friend class io_context;
-  template <typename, unsigned int> friend class basic_executor_type;
+  template <typename, uintptr_t> friend class basic_executor_type;
 
   // Constructor used by io_context::get_executor().
   explicit basic_executor_type(io_context& i) BOOST_ASIO_NOEXCEPT
-    : io_context_(&i),
-      allocator_(),
-      bits_(0)
+    : Allocator(),
+      target_(reinterpret_cast<uintptr_t>(&i))
   {
     if (Bits & outstanding_work_tracked)
-      io_context_->impl_.work_started();
+      context_ptr()->impl_.work_started();
   }
 
   // Constructor used by require().
   basic_executor_type(io_context* i,
-      const Allocator& a, unsigned int bits) BOOST_ASIO_NOEXCEPT
-    : io_context_(i),
-      allocator_(a),
-      bits_(bits)
+      const Allocator& a, uintptr_t bits) BOOST_ASIO_NOEXCEPT
+    : Allocator(a),
+      target_(reinterpret_cast<uintptr_t>(i) | bits)
   {
     if (Bits & outstanding_work_tracked)
-      if (io_context_)
-        io_context_->impl_.work_started();
+      if (context_ptr())
+        context_ptr()->impl_.work_started();
   }
 
-  // The underlying io_context.
-  io_context* io_context_;
+  io_context* context_ptr() const BOOST_ASIO_NOEXCEPT
+  {
+    return reinterpret_cast<io_context*>(target_ & ~runtime_bits);
+  }
 
-  // The allocator used for execution functions.
-  Allocator allocator_;
+  uintptr_t bits() const BOOST_ASIO_NOEXCEPT
+  {
+    return target_ & runtime_bits;
+  }
 
-  // The runtime-switched properties of the io_context executor.
-  unsigned int bits_;
+  // The underlying io_context and runtime bits.
+  uintptr_t target_;
 };
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
@@ -1279,7 +1281,7 @@ namespace traits {
 
 #if !defined(BOOST_ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 struct equality_comparable<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>
   >
@@ -1292,7 +1294,7 @@ struct equality_comparable<
 
 #if !defined(BOOST_ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
 
-template <typename Allocator, unsigned int Bits, typename Function>
+template <typename Allocator, uintptr_t Bits, typename Function>
 struct execute_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     Function
@@ -1307,7 +1309,7 @@ struct execute_member<
 
 #if !defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 struct require_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     boost::asio::execution::blocking_t::possibly_t
@@ -1319,7 +1321,7 @@ struct require_member<
       Allocator, Bits> result_type;
 };
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 struct require_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     boost::asio::execution::blocking_t::never_t
@@ -1331,7 +1333,7 @@ struct require_member<
       Allocator, Bits> result_type;
 };
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 struct require_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     boost::asio::execution::relationship_t::fork_t
@@ -1343,7 +1345,7 @@ struct require_member<
       Allocator, Bits> result_type;
 };
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 struct require_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     boost::asio::execution::relationship_t::continuation_t
@@ -1355,7 +1357,7 @@ struct require_member<
       Allocator, Bits> result_type;
 };
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 struct require_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     boost::asio::execution::outstanding_work_t::tracked_t
@@ -1367,7 +1369,7 @@ struct require_member<
       Allocator, Bits | outstanding_work_tracked> result_type;
 };
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 struct require_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     boost::asio::execution::outstanding_work_t::untracked_t
@@ -1379,7 +1381,7 @@ struct require_member<
       Allocator, Bits & ~outstanding_work_tracked> result_type;
 };
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 struct require_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     boost::asio::execution::allocator_t<void>
@@ -1391,7 +1393,7 @@ struct require_member<
       std::allocator<void>, Bits> result_type;
 };
 
-template <unsigned int Bits,
+template <uintptr_t Bits,
     typename Allocator, typename OtherAllocator>
 struct require_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
@@ -1408,7 +1410,7 @@ struct require_member<
 
 #if !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
 
-template <typename Allocator, unsigned int Bits, typename Property>
+template <typename Allocator, uintptr_t Bits, typename Property>
 struct query_static_constexpr_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     Property,
@@ -1432,7 +1434,7 @@ struct query_static_constexpr_member<
   }
 };
 
-template <typename Allocator, unsigned int Bits, typename Property>
+template <typename Allocator, uintptr_t Bits, typename Property>
 struct query_static_constexpr_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     Property,
@@ -1458,7 +1460,7 @@ struct query_static_constexpr_member<
 
 #if !defined(BOOST_ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
 
-template <typename Allocator, unsigned int Bits, typename Property>
+template <typename Allocator, uintptr_t Bits, typename Property>
 struct query_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     Property,
@@ -1475,7 +1477,7 @@ struct query_member<
   typedef boost::asio::execution::blocking_t result_type;
 };
 
-template <typename Allocator, unsigned int Bits, typename Property>
+template <typename Allocator, uintptr_t Bits, typename Property>
 struct query_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     Property,
@@ -1492,7 +1494,7 @@ struct query_member<
   typedef boost::asio::execution::relationship_t result_type;
 };
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 struct query_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     boost::asio::execution::context_t
@@ -1503,7 +1505,7 @@ struct query_member<
   typedef boost::asio::io_context& result_type;
 };
 
-template <typename Allocator, unsigned int Bits>
+template <typename Allocator, uintptr_t Bits>
 struct query_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     boost::asio::execution::allocator_t<void>
@@ -1514,7 +1516,7 @@ struct query_member<
   typedef Allocator result_type;
 };
 
-template <typename Allocator, unsigned int Bits, typename OtherAllocator>
+template <typename Allocator, uintptr_t Bits, typename OtherAllocator>
 struct query_member<
     boost::asio::io_context::basic_executor_type<Allocator, Bits>,
     boost::asio::execution::allocator_t<OtherAllocator>
@@ -1529,6 +1531,15 @@ struct query_member<
 
 } // namespace traits
 
+namespace execution {
+
+template <>
+struct is_executor<io_context> : false_type
+{
+};
+
+} // namespace execution
+
 #endif // !defined(GENERATING_DOCUMENTATION)
 
 } // namespace asio
diff --git a/boost/asio/io_context_strand.hpp b/boost/asio/io_context_strand.hpp
index b03571fe1bb37555f071a765dad0c70a48674da5..c857f8f141edd299f648319aff081e4537be5e5a 100644
--- a/boost/asio/io_context_strand.hpp
+++ b/boost/asio/io_context_strand.hpp
@@ -2,7 +2,7 @@
 // io_context_strand.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/io_service.hpp b/boost/asio/io_service.hpp
index aa8af6243971289c6a9ed70ddbc285582c987cf3..51dda2fb08fb2d3453f1e3c9bb969e6376547355 100644
--- a/boost/asio/io_service.hpp
+++ b/boost/asio/io_service.hpp
@@ -2,7 +2,7 @@
 // io_service.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/io_service_strand.hpp b/boost/asio/io_service_strand.hpp
index 2bcf8fbd6edcc45761912f5402abf5e70cb433e9..2822ccae097747b41b521f25cc05f79c22aedf44 100644
--- a/boost/asio/io_service_strand.hpp
+++ b/boost/asio/io_service_strand.hpp
@@ -2,7 +2,7 @@
 // io_service_strand.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/address.hpp b/boost/asio/ip/address.hpp
index 0fcbbf2b0f9295b66c6bb999fca1255ed0cdd51c..2fe071cbaa16f642222ea74a070e4484acdb26d6 100644
--- a/boost/asio/ip/address.hpp
+++ b/boost/asio/ip/address.hpp
@@ -2,7 +2,7 @@
 // ip/address.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/address_v4.hpp b/boost/asio/ip/address_v4.hpp
index 19d5b313a83cf932fd10649c9c4b0fcb829f624f..1eec2531e6a951c9ac417dd0d32415a273872224 100644
--- a/boost/asio/ip/address_v4.hpp
+++ b/boost/asio/ip/address_v4.hpp
@@ -2,7 +2,7 @@
 // ip/address_v4.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/address_v4_iterator.hpp b/boost/asio/ip/address_v4_iterator.hpp
index df67a8bd03a2b2d311c76242dc969ad6ac70b47a..46ff23ede4b1b69224487c96e634183e361d8046 100644
--- a/boost/asio/ip/address_v4_iterator.hpp
+++ b/boost/asio/ip/address_v4_iterator.hpp
@@ -2,7 +2,7 @@
 // ip/address_v4_iterator.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/address_v4_range.hpp b/boost/asio/ip/address_v4_range.hpp
index a939aedc8b8dee7ce61e772e65aaeb4f09819c00..1d8ccf50e3692d1c7f030aacfb1e92566c95f9b7 100644
--- a/boost/asio/ip/address_v4_range.hpp
+++ b/boost/asio/ip/address_v4_range.hpp
@@ -2,7 +2,7 @@
 // ip/address_v4_range.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/address_v6.hpp b/boost/asio/ip/address_v6.hpp
index 4f21d969486ff67c03908e5c1e5768a7b170101c..4a678fc77b0222defe30911c589685fede074ede 100644
--- a/boost/asio/ip/address_v6.hpp
+++ b/boost/asio/ip/address_v6.hpp
@@ -2,7 +2,7 @@
 // ip/address_v6.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/address_v6_iterator.hpp b/boost/asio/ip/address_v6_iterator.hpp
index 49c9bde8fd6afca085468bd8ec60ff5fc391ecff..71f40f4e6d456871e060506de41777ddb865e6a8 100644
--- a/boost/asio/ip/address_v6_iterator.hpp
+++ b/boost/asio/ip/address_v6_iterator.hpp
@@ -2,7 +2,7 @@
 // ip/address_v6_iterator.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //                         Oliver Kowalke (oliver dot kowalke at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/ip/address_v6_range.hpp b/boost/asio/ip/address_v6_range.hpp
index 745be4fdf65e0828dfc93a37392639f3f0e934f0..05a4ed52e85b6048654bbcf86f64a26b72d630d1 100644
--- a/boost/asio/ip/address_v6_range.hpp
+++ b/boost/asio/ip/address_v6_range.hpp
@@ -2,7 +2,7 @@
 // ip/address_v6_range.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //                         Oliver Kowalke (oliver dot kowalke at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/ip/bad_address_cast.hpp b/boost/asio/ip/bad_address_cast.hpp
index dd12a9f1d2ef770629e9190729dd57dcc9a2955b..7a3097a49bf46c9a1a7e2a0fc71d2fea1fe422fc 100644
--- a/boost/asio/ip/bad_address_cast.hpp
+++ b/boost/asio/ip/bad_address_cast.hpp
@@ -2,7 +2,7 @@
 // ip/bad_address_cast.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/basic_endpoint.hpp b/boost/asio/ip/basic_endpoint.hpp
index e7b66fc1f6a770ac1213efdb4af3af9d8cf76323..e1e17841e6c6345c836b609cc366a964754c7e08 100644
--- a/boost/asio/ip/basic_endpoint.hpp
+++ b/boost/asio/ip/basic_endpoint.hpp
@@ -2,7 +2,7 @@
 // ip/basic_endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/basic_resolver.hpp b/boost/asio/ip/basic_resolver.hpp
index 66ecfdb7b2862cd5a4e6079f1b138a8bb023854d..8b611a44dd7ac683685c06d5d37881fb7e61c721 100644
--- a/boost/asio/ip/basic_resolver.hpp
+++ b/boost/asio/ip/basic_resolver.hpp
@@ -2,7 +2,7 @@
 // ip/basic_resolver.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -648,38 +648,44 @@ public:
   /// Asynchronously perform forward resolution of a query to a list of entries.
   /**
    * This function is used to asynchronously resolve a query into a list of
-   * endpoint entries.
+   * endpoint entries. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param q A query object that determines what endpoints will be returned.
    *
-   * @param handler The handler to be called when the resolve operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the resolve completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   resolver::results_type results // Resolved endpoints as a range.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
    * A successful resolve operation is guaranteed to pass a non-empty range to
    * the handler.
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, results_type) @endcode
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        results_type)) ResolveHandler
+        results_type)) ResolveToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveToken,
       void (boost::system::error_code, results_type))
   async_resolve(const query& q,
-      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler
+      BOOST_ASIO_MOVE_ARG(ResolveToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return boost::asio::async_initiate<ResolveHandler,
+    return boost::asio::async_initiate<ResolveToken,
       void (boost::system::error_code, results_type)>(
-        initiate_async_resolve(this), handler, q);
+        initiate_async_resolve(this), token, q);
   }
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
@@ -699,21 +705,26 @@ public:
    * be an empty string, in which case all resolved endpoints will have a port
    * number of 0.
    *
-   * @param handler The handler to be called when the resolve operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the resolve completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   resolver::results_type results // Resolved endpoints as a range.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
    * A successful resolve operation is guaranteed to pass a non-empty range to
    * the handler.
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, results_type) @endcode
+   *
    * @note On POSIX systems, host names may be locally defined in the file
    * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
    * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
@@ -727,23 +738,24 @@ public:
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        results_type)) ResolveHandler
+        results_type)) ResolveToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveToken,
       void (boost::system::error_code, results_type))
   async_resolve(BOOST_ASIO_STRING_VIEW_PARAM host,
       BOOST_ASIO_STRING_VIEW_PARAM service,
-      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler
+      BOOST_ASIO_MOVE_ARG(ResolveToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
     return async_resolve(host, service, resolver_base::flags(),
-        BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler));
+        BOOST_ASIO_MOVE_CAST(ResolveToken)(token));
   }
 
   /// Asynchronously perform forward resolution of a query to a list of entries.
   /**
    * This function is used to resolve host and service names into a list of
-   * endpoint entries.
+   * endpoint entries. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param host A string identifying a location. May be a descriptive name or
    * a numeric address string. If an empty string and the passive flag has been
@@ -761,21 +773,26 @@ public:
    * remote hosts. See the @ref resolver_base documentation for the set of
    * available flags.
    *
-   * @param handler The handler to be called when the resolve operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the resolve completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   resolver::results_type results // Resolved endpoints as a range.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
    * A successful resolve operation is guaranteed to pass a non-empty range to
    * the handler.
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, results_type) @endcode
+   *
    * @note On POSIX systems, host names may be locally defined in the file
    * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
    * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
@@ -789,28 +806,29 @@ public:
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        results_type)) ResolveHandler
+        results_type)) ResolveToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveToken,
       void (boost::system::error_code, results_type))
   async_resolve(BOOST_ASIO_STRING_VIEW_PARAM host,
       BOOST_ASIO_STRING_VIEW_PARAM service,
       resolver_base::flags resolve_flags,
-      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler
+      BOOST_ASIO_MOVE_ARG(ResolveToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
     basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
         static_cast<std::string>(service), resolve_flags);
 
-    return boost::asio::async_initiate<ResolveHandler,
+    return boost::asio::async_initiate<ResolveToken,
       void (boost::system::error_code, results_type)>(
-        initiate_async_resolve(this), handler, q);
+        initiate_async_resolve(this), token, q);
   }
 
   /// Asynchronously perform forward resolution of a query to a list of entries.
   /**
    * This function is used to resolve host and service names into a list of
-   * endpoint entries.
+   * endpoint entries. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param protocol A protocol object, normally representing either the IPv4 or
    * IPv6 version of an internet protocol.
@@ -826,21 +844,26 @@ public:
    * be an empty string, in which case all resolved endpoints will have a port
    * number of 0.
    *
-   * @param handler The handler to be called when the resolve operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the resolve completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   resolver::results_type results // Resolved endpoints as a range.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
    * A successful resolve operation is guaranteed to pass a non-empty range to
    * the handler.
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, results_type) @endcode
+   *
    * @note On POSIX systems, host names may be locally defined in the file
    * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
    * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
@@ -854,23 +877,24 @@ public:
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        results_type)) ResolveHandler
+        results_type)) ResolveToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveToken,
       void (boost::system::error_code, results_type))
   async_resolve(const protocol_type& protocol,
       BOOST_ASIO_STRING_VIEW_PARAM host, BOOST_ASIO_STRING_VIEW_PARAM service,
-      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler
+      BOOST_ASIO_MOVE_ARG(ResolveToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
     return async_resolve(protocol, host, service, resolver_base::flags(),
-        BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler));
+        BOOST_ASIO_MOVE_CAST(ResolveToken)(token));
   }
 
   /// Asynchronously perform forward resolution of a query to a list of entries.
   /**
    * This function is used to resolve host and service names into a list of
-   * endpoint entries.
+   * endpoint entries. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param protocol A protocol object, normally representing either the IPv4 or
    * IPv6 version of an internet protocol.
@@ -891,21 +915,26 @@ public:
    * remote hosts. See the @ref resolver_base documentation for the set of
    * available flags.
    *
-   * @param handler The handler to be called when the resolve operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the resolve completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   resolver::results_type results // Resolved endpoints as a range.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
    * A successful resolve operation is guaranteed to pass a non-empty range to
    * the handler.
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, results_type) @endcode
+   *
    * @note On POSIX systems, host names may be locally defined in the file
    * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
    * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
@@ -919,23 +948,23 @@ public:
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        results_type)) ResolveHandler
+        results_type)) ResolveToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveToken,
       void (boost::system::error_code, results_type))
   async_resolve(const protocol_type& protocol,
       BOOST_ASIO_STRING_VIEW_PARAM host, BOOST_ASIO_STRING_VIEW_PARAM service,
       resolver_base::flags resolve_flags,
-      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler
+      BOOST_ASIO_MOVE_ARG(ResolveToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
     basic_resolver_query<protocol_type> q(
         protocol, static_cast<std::string>(host),
         static_cast<std::string>(service), resolve_flags);
 
-    return boost::asio::async_initiate<ResolveHandler,
+    return boost::asio::async_initiate<ResolveToken,
       void (boost::system::error_code, results_type)>(
-        initiate_async_resolve(this), handler, q);
+        initiate_async_resolve(this), token, q);
   }
 
   /// Perform reverse resolution of an endpoint to a list of entries.
@@ -984,39 +1013,45 @@ public:
   /// entries.
   /**
    * This function is used to asynchronously resolve an endpoint into a list of
-   * endpoint entries.
+   * endpoint entries. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param e An endpoint object that determines what endpoints will be
    * returned.
    *
-   * @param handler The handler to be called when the resolve operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the resolve completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   resolver::results_type results // Resolved endpoints as a range.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
    * A successful resolve operation is guaranteed to pass a non-empty range to
    * the handler.
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, results_type) @endcode
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        results_type)) ResolveHandler
+        results_type)) ResolveToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveToken,
       void (boost::system::error_code, results_type))
   async_resolve(const endpoint_type& e,
-      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler
+      BOOST_ASIO_MOVE_ARG(ResolveToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return boost::asio::async_initiate<ResolveHandler,
+    return boost::asio::async_initiate<ResolveToken,
       void (boost::system::error_code, results_type)>(
-        initiate_async_resolve(this), handler, e);
+        initiate_async_resolve(this), token, e);
   }
 
 private:
diff --git a/boost/asio/ip/basic_resolver_entry.hpp b/boost/asio/ip/basic_resolver_entry.hpp
index cb6d46f1b9dcd687c08c30237eb1b5895bb05024..b1fe5ab16d05169827bfa5c73fbf97f0284881ae 100644
--- a/boost/asio/ip/basic_resolver_entry.hpp
+++ b/boost/asio/ip/basic_resolver_entry.hpp
@@ -2,7 +2,7 @@
 // ip/basic_resolver_entry.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/basic_resolver_iterator.hpp b/boost/asio/ip/basic_resolver_iterator.hpp
index db404ae28a4678eea717a1714c8d322e2a5cf478..08e2b7ece02fae8ac7d0d43278a10ecef440b395 100644
--- a/boost/asio/ip/basic_resolver_iterator.hpp
+++ b/boost/asio/ip/basic_resolver_iterator.hpp
@@ -2,7 +2,7 @@
 // ip/basic_resolver_iterator.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/basic_resolver_query.hpp b/boost/asio/ip/basic_resolver_query.hpp
index 0eceaae008bb8724705f6bcb7ae4b45c5db1a4be..e6a0b466a9fdabbeacf3e9a8d12e9944d1181a85 100644
--- a/boost/asio/ip/basic_resolver_query.hpp
+++ b/boost/asio/ip/basic_resolver_query.hpp
@@ -2,7 +2,7 @@
 // ip/basic_resolver_query.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/basic_resolver_results.hpp b/boost/asio/ip/basic_resolver_results.hpp
index 0989971ce8eae65b5a6f44271d143e08126ae48a..bdf448e8332beab41841f8f0bc9b616f02a237a4 100644
--- a/boost/asio/ip/basic_resolver_results.hpp
+++ b/boost/asio/ip/basic_resolver_results.hpp
@@ -2,7 +2,7 @@
 // ip/basic_resolver_results.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/detail/endpoint.hpp b/boost/asio/ip/detail/endpoint.hpp
index 23d4abdc12f3e2dacce77be82cd49aa22431b1a1..660b273a58684718cccb5c0b3e5ce9df30c5f1d1 100644
--- a/boost/asio/ip/detail/endpoint.hpp
+++ b/boost/asio/ip/detail/endpoint.hpp
@@ -2,7 +2,7 @@
 // ip/detail/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/detail/impl/endpoint.ipp b/boost/asio/ip/detail/impl/endpoint.ipp
index 0219e14a8281e57232ba08978fbc1a4d22df91fe..c1dfd247a744700a8fa3f42bae26beb93dca642b 100644
--- a/boost/asio/ip/detail/impl/endpoint.ipp
+++ b/boost/asio/ip/detail/impl/endpoint.ipp
@@ -2,7 +2,7 @@
 // ip/detail/impl/endpoint.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/detail/socket_option.hpp b/boost/asio/ip/detail/socket_option.hpp
index 10a6cd2c5cf9a67391f8bb91afa5fdec7618f2c8..7e64c72ca555d9d12a0b3a94785db965fa6c007c 100644
--- a/boost/asio/ip/detail/socket_option.hpp
+++ b/boost/asio/ip/detail/socket_option.hpp
@@ -2,7 +2,7 @@
 // detail/socket_option.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/host_name.hpp b/boost/asio/ip/host_name.hpp
index 65fb688a93100d8ba249f6c0f6b1f170f2bf5b70..8c4acac0c1a8b0e39c355dd7a5401441efe86fbd 100644
--- a/boost/asio/ip/host_name.hpp
+++ b/boost/asio/ip/host_name.hpp
@@ -2,7 +2,7 @@
 // ip/host_name.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/icmp.hpp b/boost/asio/ip/icmp.hpp
index d2ea36733166b19642db337107990958f4581c44..b676d61f35479c4cb74d70aced8414cdfd59ddde 100644
--- a/boost/asio/ip/icmp.hpp
+++ b/boost/asio/ip/icmp.hpp
@@ -2,7 +2,7 @@
 // ip/icmp.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/impl/address.hpp b/boost/asio/ip/impl/address.hpp
index da8a804f44028ec0df60a3ad02eb878b6cbe709e..d14f5334dc516177235aa781c805bafa4e1532c4 100644
--- a/boost/asio/ip/impl/address.hpp
+++ b/boost/asio/ip/impl/address.hpp
@@ -2,7 +2,7 @@
 // ip/impl/address.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/impl/address.ipp b/boost/asio/ip/impl/address.ipp
index a35a442a30334e529158a1cae6b2f18cb729d83d..348e477f9b8fb6a70acfd9193522190229e2422e 100644
--- a/boost/asio/ip/impl/address.ipp
+++ b/boost/asio/ip/impl/address.ipp
@@ -2,7 +2,7 @@
 // ip/impl/address.ipp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/impl/address_v4.hpp b/boost/asio/ip/impl/address_v4.hpp
index d2a26983afe0ea30536f20871c6e81632f6b3d51..1c18933cbf28e7011985b71e87a41145b2e690de 100644
--- a/boost/asio/ip/impl/address_v4.hpp
+++ b/boost/asio/ip/impl/address_v4.hpp
@@ -2,7 +2,7 @@
 // ip/impl/address_v4.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/impl/address_v4.ipp b/boost/asio/ip/impl/address_v4.ipp
index 5f7f35fd34b934e774f8e9a5b010a76d8b2836d1..5e1ae45d74e2431a7d2322344fed199395082ff6 100644
--- a/boost/asio/ip/impl/address_v4.ipp
+++ b/boost/asio/ip/impl/address_v4.ipp
@@ -2,7 +2,7 @@
 // ip/impl/address_v4.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/impl/address_v6.hpp b/boost/asio/ip/impl/address_v6.hpp
index 3f15561038a0e29f7b94e918112ff94f54b8f9ca..e9c50188a1511e71b1f443894dc5f8d4135de538 100644
--- a/boost/asio/ip/impl/address_v6.hpp
+++ b/boost/asio/ip/impl/address_v6.hpp
@@ -2,7 +2,7 @@
 // ip/impl/address_v6.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/impl/address_v6.ipp b/boost/asio/ip/impl/address_v6.ipp
index 2d7b92ea6001183389fd528228a8d66bd09200c9..4cd615a7d0616bd92cb4987c82bb4b99ed72bda6 100644
--- a/boost/asio/ip/impl/address_v6.ipp
+++ b/boost/asio/ip/impl/address_v6.ipp
@@ -2,7 +2,7 @@
 // ip/impl/address_v6.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/impl/basic_endpoint.hpp b/boost/asio/ip/impl/basic_endpoint.hpp
index 138184cd6c5ddc987d65cd77010c4c0ef6aa5fa6..227e191bbb85c56b26862a40bf0a8355bf7cdf02 100644
--- a/boost/asio/ip/impl/basic_endpoint.hpp
+++ b/boost/asio/ip/impl/basic_endpoint.hpp
@@ -2,7 +2,7 @@
 // ip/impl/basic_endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/impl/host_name.ipp b/boost/asio/ip/impl/host_name.ipp
index dcec903954d3b015801811450a8c17ec541e4654..5c0e723c6bd9ba8bb19d5fca8bd33c3496f9f05c 100644
--- a/boost/asio/ip/impl/host_name.ipp
+++ b/boost/asio/ip/impl/host_name.ipp
@@ -2,7 +2,7 @@
 // ip/impl/host_name.ipp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/impl/network_v4.hpp b/boost/asio/ip/impl/network_v4.hpp
index 69c5043a3104e87a2a83b7d601fb2cb66ad20d79..21dd8fce6e7eec45335e798b403a80e9ae263ee5 100644
--- a/boost/asio/ip/impl/network_v4.hpp
+++ b/boost/asio/ip/impl/network_v4.hpp
@@ -2,7 +2,7 @@
 // ip/impl/network_v4.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/ip/impl/network_v4.ipp b/boost/asio/ip/impl/network_v4.ipp
index 7be2aae25e8d6a0cee179de7e75ec6acd8331aca..9d7d1fbfd26891609bd58be67eb113a256f74ef9 100644
--- a/boost/asio/ip/impl/network_v4.ipp
+++ b/boost/asio/ip/impl/network_v4.ipp
@@ -2,7 +2,7 @@
 // ip/impl/network_v4.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/ip/impl/network_v6.hpp b/boost/asio/ip/impl/network_v6.hpp
index db7dde0d6b2a71bdb9c14f116e53c0a186d39ec5..a43c958e155c66232982ebcea71c31b8800e770a 100644
--- a/boost/asio/ip/impl/network_v6.hpp
+++ b/boost/asio/ip/impl/network_v6.hpp
@@ -2,7 +2,7 @@
 // ip/impl/network_v6.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/impl/network_v6.ipp b/boost/asio/ip/impl/network_v6.ipp
index 7ca7e8146a35c7223a39455d404035562e662856..ce189c1b41d4abc658e913b72344373b5c8f7499 100644
--- a/boost/asio/ip/impl/network_v6.ipp
+++ b/boost/asio/ip/impl/network_v6.ipp
@@ -2,7 +2,7 @@
 // ip/impl/network_v6.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/ip/multicast.hpp b/boost/asio/ip/multicast.hpp
index 62ae40e28bd3a78851f07776d3547edc1f25587e..f28cd4da9a59697f4f3b7341c6d529b8e4f9a5f7 100644
--- a/boost/asio/ip/multicast.hpp
+++ b/boost/asio/ip/multicast.hpp
@@ -2,7 +2,7 @@
 // ip/multicast.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/network_v4.hpp b/boost/asio/ip/network_v4.hpp
index ffe674050c5a654d0c8137ea532ca6ba6b1d747d..729cc5c168f5931e026a14f88f794223df287c80 100644
--- a/boost/asio/ip/network_v4.hpp
+++ b/boost/asio/ip/network_v4.hpp
@@ -2,7 +2,7 @@
 // ip/network_v4.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -123,7 +123,7 @@ public:
   /// Obtain the true network address, omitting any host bits.
   network_v4 canonical() const BOOST_ASIO_NOEXCEPT
   {
-    return network_v4(network(), netmask());
+    return network_v4(network(), prefix_length());
   }
 
   /// Test if network is a valid host address.
diff --git a/boost/asio/ip/network_v6.hpp b/boost/asio/ip/network_v6.hpp
index 902bb774d81d04cd2cece2cd4f4d3b82c56e7614..d157dcd8e2faf0cdf8f2a6c782e8e0acf08b732e 100644
--- a/boost/asio/ip/network_v6.hpp
+++ b/boost/asio/ip/network_v6.hpp
@@ -2,7 +2,7 @@
 // ip/network_v6.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/ip/resolver_base.hpp b/boost/asio/ip/resolver_base.hpp
index 95f8d90262413c70144da1f8450b84767ce8e1b1..e32fc272fb42a27a6ca37c6e1bdb7821ea2287da 100644
--- a/boost/asio/ip/resolver_base.hpp
+++ b/boost/asio/ip/resolver_base.hpp
@@ -2,7 +2,7 @@
 // ip/resolver_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/resolver_query_base.hpp b/boost/asio/ip/resolver_query_base.hpp
index 8b799c24a6457868bd90d5276ae52a9205d97dd5..95b9364c2c39db5caa1f6bd0eb598eb307ac46ca 100644
--- a/boost/asio/ip/resolver_query_base.hpp
+++ b/boost/asio/ip/resolver_query_base.hpp
@@ -2,7 +2,7 @@
 // ip/resolver_query_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/tcp.hpp b/boost/asio/ip/tcp.hpp
index 926f2a9ae24d238e4994dba165bf54db8f1b6cc2..3c26c16bacfd98d75b7a508b05b790cdc88b775a 100644
--- a/boost/asio/ip/tcp.hpp
+++ b/boost/asio/ip/tcp.hpp
@@ -2,7 +2,7 @@
 // ip/tcp.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/udp.hpp b/boost/asio/ip/udp.hpp
index f0a72d03a10e42fc6bfbcd2e090fc9a9d6dee5f4..548a034ba62a34074b1c86ac77bfa11b05ae630b 100644
--- a/boost/asio/ip/udp.hpp
+++ b/boost/asio/ip/udp.hpp
@@ -2,7 +2,7 @@
 // ip/udp.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/unicast.hpp b/boost/asio/ip/unicast.hpp
index 916eebc56e5404558a4b6a56c4fa82fb794c7fcf..b575f78a0ae54918e0d11166dacce6230388a42b 100644
--- a/boost/asio/ip/unicast.hpp
+++ b/boost/asio/ip/unicast.hpp
@@ -2,7 +2,7 @@
 // ip/unicast.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ip/v6_only.hpp b/boost/asio/ip/v6_only.hpp
index 92dcc83a26be1b55ae658063509f5e2d060323de..d21edfcd50187d007ac1c3462d35d7dfa18edd19 100644
--- a/boost/asio/ip/v6_only.hpp
+++ b/boost/asio/ip/v6_only.hpp
@@ -2,7 +2,7 @@
 // ip/v6_only.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -27,7 +27,7 @@ namespace ip {
 /// Socket option for determining whether an IPv6 socket supports IPv6
 /// communication only.
 /**
- * Implements the IPPROTO_IPV6/IP_V6ONLY socket option.
+ * Implements the IPPROTO_IPV6/IPV6_V6ONLY socket option.
  *
  * @par Examples
  * Setting the option:
diff --git a/boost/asio/is_applicable_property.hpp b/boost/asio/is_applicable_property.hpp
index 41bd6745c6d59faac92f3c28dcefb2d92e35c11b..0dfa00b63881a2aa6f54a81078f6d12ceeb2f37c 100644
--- a/boost/asio/is_applicable_property.hpp
+++ b/boost/asio/is_applicable_property.hpp
@@ -2,7 +2,7 @@
 // is_applicable_property.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/is_executor.hpp b/boost/asio/is_executor.hpp
index 1ef476f83d162e2277407cf2c18c84828e940798..ba38fabe911767625462d22ae49316de360cfded 100644
--- a/boost/asio/is_executor.hpp
+++ b/boost/asio/is_executor.hpp
@@ -2,7 +2,7 @@
 // is_executor.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/is_read_buffered.hpp b/boost/asio/is_read_buffered.hpp
index a28eb4055870a2ebfa3064174ca573a889ffb771..adf3136c9f305bf59ceac9bbd2e27936302632cb 100644
--- a/boost/asio/is_read_buffered.hpp
+++ b/boost/asio/is_read_buffered.hpp
@@ -2,7 +2,7 @@
 // is_read_buffered.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/is_write_buffered.hpp b/boost/asio/is_write_buffered.hpp
index 19dee98df62cceaa4cb147c1dbcbeab42223a9db..4c74d205c271491062a7e3d74b92435c161b5750 100644
--- a/boost/asio/is_write_buffered.hpp
+++ b/boost/asio/is_write_buffered.hpp
@@ -2,7 +2,7 @@
 // is_write_buffered.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/local/basic_endpoint.hpp b/boost/asio/local/basic_endpoint.hpp
index e622717679ad227a4adc8205f768d597aaf67388..305a76cc3ad44759a0b7b60a477fb209550f82c3 100644
--- a/boost/asio/local/basic_endpoint.hpp
+++ b/boost/asio/local/basic_endpoint.hpp
@@ -2,7 +2,7 @@
 // local/basic_endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Derived from a public domain implementation written by Daniel Casimiro.
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/local/connect_pair.hpp b/boost/asio/local/connect_pair.hpp
index aefc1d76d7d8a9786af56e3ef78c94e52c04078b..0fead446a35d389ff9e539ddb1dbdfe6e9685266 100644
--- a/boost/asio/local/connect_pair.hpp
+++ b/boost/asio/local/connect_pair.hpp
@@ -2,7 +2,7 @@
 // local/connect_pair.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/local/datagram_protocol.hpp b/boost/asio/local/datagram_protocol.hpp
index 4597836b186eeed3119ac696cefa8a5e2189958b..2fc9c46467cad457e2940edae26c796566a7a87b 100644
--- a/boost/asio/local/datagram_protocol.hpp
+++ b/boost/asio/local/datagram_protocol.hpp
@@ -2,7 +2,7 @@
 // local/datagram_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/local/detail/endpoint.hpp b/boost/asio/local/detail/endpoint.hpp
index 38c0b442c3e7e8843e87c335c919314f44c01c5d..b35622e20c69926c537bb21a3aff83be696f061b 100644
--- a/boost/asio/local/detail/endpoint.hpp
+++ b/boost/asio/local/detail/endpoint.hpp
@@ -2,7 +2,7 @@
 // local/detail/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Derived from a public domain implementation written by Daniel Casimiro.
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/local/detail/impl/endpoint.ipp b/boost/asio/local/detail/impl/endpoint.ipp
index 1a327eb484a17c3fced0fd75d803b0e1150bcde3..49f8ac7bdb1d64986b9b6cfcb1067d8f2eb9fd66 100644
--- a/boost/asio/local/detail/impl/endpoint.ipp
+++ b/boost/asio/local/detail/impl/endpoint.ipp
@@ -2,7 +2,7 @@
 // local/detail/impl/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Derived from a public domain implementation written by Daniel Casimiro.
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -113,17 +113,12 @@ void endpoint::init(const char* path_name, std::size_t path_length)
     boost::asio::detail::throw_error(ec);
   }
 
-  using namespace std; // For memcpy.
-  data_.local = boost::asio::detail::sockaddr_un_type();
+  using namespace std; // For memset and memcpy.
+  memset(&data_.local, 0, sizeof(boost::asio::detail::sockaddr_un_type));
   data_.local.sun_family = AF_UNIX;
   if (path_length > 0)
     memcpy(data_.local.sun_path, path_name, path_length);
   path_length_ = path_length;
-
-  // NUL-terminate normal path names. Names that start with a NUL are in the
-  // UNIX domain protocol's "abstract namespace" and are not NUL-terminated.
-  if (path_length > 0 && data_.local.sun_path[0] == 0)
-    data_.local.sun_path[path_length] = 0;
 }
 
 } // namespace detail
diff --git a/boost/asio/local/stream_protocol.hpp b/boost/asio/local/stream_protocol.hpp
index af1700004810c11d32e0c1659b77132ea4e99730..0e2f91ec15573f93b5af626c6347b7d7fb80dbad 100644
--- a/boost/asio/local/stream_protocol.hpp
+++ b/boost/asio/local/stream_protocol.hpp
@@ -2,7 +2,7 @@
 // local/stream_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/multiple_exceptions.hpp b/boost/asio/multiple_exceptions.hpp
index 2534c818ad96dc2879cc942b26f0e32ec05f5468..313b121697778eb3baa9705dd104f9bd666e220f 100644
--- a/boost/asio/multiple_exceptions.hpp
+++ b/boost/asio/multiple_exceptions.hpp
@@ -2,7 +2,7 @@
 // multiple_exceptions.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/packaged_task.hpp b/boost/asio/packaged_task.hpp
index 24575888083f30a758aa96aedf3d8c225446948f..fc531146ca190092646e4a59e0d177817fd45a83 100644
--- a/boost/asio/packaged_task.hpp
+++ b/boost/asio/packaged_task.hpp
@@ -2,7 +2,7 @@
 // packaged_task.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/placeholders.hpp b/boost/asio/placeholders.hpp
index 5b5bcde26a1df6941151f6a7a82121686bca8478..b59901ed4a9cd6853c27e55ae921f96dee4cb016 100644
--- a/boost/asio/placeholders.hpp
+++ b/boost/asio/placeholders.hpp
@@ -2,7 +2,7 @@
 // placeholders.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/posix/basic_descriptor.hpp b/boost/asio/posix/basic_descriptor.hpp
index d9a2d726c5d1e3593de20474c45759efc9539cac..18d2269033ee3dbe189ddc59ee078468feb79827 100644
--- a/boost/asio/posix/basic_descriptor.hpp
+++ b/boost/asio/posix/basic_descriptor.hpp
@@ -2,7 +2,7 @@
 // posix/basic_descriptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -25,12 +25,17 @@
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/io_object_impl.hpp>
 #include <boost/asio/detail/non_const_lvalue.hpp>
-#include <boost/asio/detail/reactive_descriptor_service.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/execution_context.hpp>
 #include <boost/asio/posix/descriptor_base.hpp>
 
+#if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/io_uring_descriptor_service.hpp>
+#else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/reactive_descriptor_service.hpp>
+#endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+
 #if defined(BOOST_ASIO_HAS_MOVE)
 # include <utility>
 #endif // defined(BOOST_ASIO_HAS_MOVE)
@@ -69,10 +74,13 @@ public:
   /// The native representation of a descriptor.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined native_handle_type;
-#else
+#elif defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  typedef detail::io_uring_descriptor_service::native_handle_type
+    native_handle_type;
+#else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
   typedef detail::reactive_descriptor_service::native_handle_type
     native_handle_type;
-#endif
+#endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
   /// A descriptor is always the lowest layer.
   typedef basic_descriptor lowest_layer_type;
@@ -590,21 +598,28 @@ public:
   /// write, or to have pending error conditions.
   /**
    * This function is used to perform an asynchronous wait for a descriptor to
-   * enter a ready to read, write or error condition state.
+   * enter a ready to read, write or error condition state. It is an initiating
+   * function for an @ref asynchronous_operation, and always returns
+   * immediately.
    *
    * @param w Specifies the desired descriptor state.
    *
-   * @param handler The handler to be called when the wait operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the wait completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
-   *   const boost::system::error_code& error // Result of operation
+   *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
    * @par Example
    * @code
    * void wait_handler(const boost::system::error_code& error)
@@ -623,18 +638,28 @@ public:
    *     boost::asio::posix::stream_descriptor::wait_read,
    *     wait_handler);
    * @endcode
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
-        WaitHandler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitHandler,
+        WaitToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitToken,
       void (boost::system::error_code))
   async_wait(wait_type w,
-      BOOST_ASIO_MOVE_ARG(WaitHandler) handler
+      BOOST_ASIO_MOVE_ARG(WaitToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WaitHandler, void (boost::system::error_code)>(
-        initiate_async_wait(this), handler, w);
+    return async_initiate<WaitToken, void (boost::system::error_code)>(
+        initiate_async_wait(this), token, w);
   }
 
 protected:
@@ -648,7 +673,11 @@ protected:
   {
   }
 
+#if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  detail::io_object_impl<detail::io_uring_descriptor_service, Executor> impl_;
+#else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
   detail::io_object_impl<detail::reactive_descriptor_service, Executor> impl_;
+#endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
 private:
   // Disallow copying and assignment.
diff --git a/boost/asio/posix/basic_stream_descriptor.hpp b/boost/asio/posix/basic_stream_descriptor.hpp
index c603a395548e1f0e045a5e623b1f9d4f7d2f1a34..24da0cc7959beaf046bebe26b5854ab2298604f7 100644
--- a/boost/asio/posix/basic_stream_descriptor.hpp
+++ b/boost/asio/posix/basic_stream_descriptor.hpp
@@ -2,7 +2,7 @@
 // posix/basic_stream_descriptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,7 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/asio/posix/descriptor.hpp>
+#include <boost/asio/posix/basic_descriptor.hpp>
 
 #if defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
   || defined(GENERATING_DOCUMENTATION)
@@ -155,7 +155,7 @@ public:
    * constructor.
    */
   basic_stream_descriptor(basic_stream_descriptor&& other) BOOST_ASIO_NOEXCEPT
-    : descriptor(std::move(other))
+    : basic_descriptor<Executor>(std::move(other))
   {
   }
 
@@ -173,7 +173,7 @@ public:
    */
   basic_stream_descriptor& operator=(basic_stream_descriptor&& other)
   {
-    descriptor::operator=(std::move(other));
+    basic_descriptor<Executor>::operator=(std::move(other));
     return *this;
   }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
@@ -242,25 +242,31 @@ public:
   /// Start an asynchronous write.
   /**
    * This function is used to asynchronously write data to the stream
-   * descriptor. The function call always returns immediately.
+   * descriptor. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more data buffers to be written to the descriptor.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the write operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes written.
+   *   std::size_t bytes_transferred // Number of bytes written.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
@@ -273,20 +279,30 @@ public:
    * See the @ref buffer documentation for information on writing multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_write_some(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_write_some(this), handler, buffers);
+        initiate_async_write_some(this), token, buffers);
   }
 
   /// Read some data from the descriptor.
@@ -355,25 +371,31 @@ public:
   /// Start an asynchronous read.
   /**
    * This function is used to asynchronously read data from the stream
-   * descriptor. The function call always returns immediately.
+   * descriptor. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be read.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the read operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes read.
+   *   std::size_t bytes_transferred // Number of bytes read.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
    * requested amount of data is read before the asynchronous operation
@@ -387,20 +409,30 @@ public:
    * See the @ref buffer documentation for information on reading into multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_read_some(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_read_some(this), handler, buffers);
+        initiate_async_read_some(this), token, buffers);
   }
 
 private:
diff --git a/boost/asio/posix/descriptor.hpp b/boost/asio/posix/descriptor.hpp
index 6c03f3a7513cfec7cc3000fe602bb0f738b5760e..8a5404daaa56d657a9e5cfc4f949f443ad92a7a8 100644
--- a/boost/asio/posix/descriptor.hpp
+++ b/boost/asio/posix/descriptor.hpp
@@ -2,7 +2,7 @@
 // posix/descriptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/posix/descriptor_base.hpp b/boost/asio/posix/descriptor_base.hpp
index 6b74aa083d092538025d94bf3b880e9ddc4aa7ce..e26155133c10bf0103869053c49df211437f17ad 100644
--- a/boost/asio/posix/descriptor_base.hpp
+++ b/boost/asio/posix/descriptor_base.hpp
@@ -2,7 +2,7 @@
 // posix/descriptor_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/posix/stream_descriptor.hpp b/boost/asio/posix/stream_descriptor.hpp
index 378b4711fff8df27154bb7e5c7e5819948cee6d8..3249322e241506babd61c640110530470e5d0388 100644
--- a/boost/asio/posix/stream_descriptor.hpp
+++ b/boost/asio/posix/stream_descriptor.hpp
@@ -2,7 +2,7 @@
 // posix/stream_descriptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/post.hpp b/boost/asio/post.hpp
index aefe97337e117c5efafecddaa30360ffa439bca2..acf02ede9c37eb7b1b8fabbc43368aab47d8f0bb 100644
--- a/boost/asio/post.hpp
+++ b/boost/asio/post.hpp
@@ -2,7 +2,7 @@
 // post.hpp
 // ~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -36,27 +36,48 @@ namespace asio {
  * The use of @c post(), rather than @ref defer(), indicates the caller's
  * preference that the function object be eagerly queued for execution.
  *
- * This function has the following effects:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler. The function signature of the completion handler must be:
+ * @code void handler(); @endcode
  *
- * @li Constructs a function object handler of type @c Handler, initialized
- * with <tt>handler(forward<CompletionToken>(token))</tt>.
+ * @returns This function returns <tt>async_initiate<NullaryToken,
+ * void()>(Init{}, token)</tt>, where @c Init is a function object type defined
+ * as:
  *
- * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
- * initializing the object as <tt>result(handler)</tt>.
+ * @code class Init
+ * {
+ * public:
+ *   template <typename CompletionHandler>
+ *     void operator()(CompletionHandler&& completion_handler) const;
+ * }; @endcode
  *
- * @li Obtains the handler's associated executor object @c ex by performing
- * <tt>get_associated_executor(handler)</tt>.
+ * The function call operator of @c Init:
  *
- * @li Obtains the handler's associated allocator object @c alloc by performing
- * <tt>get_associated_allocator(handler)</tt>.
- *
- * @li Performs <tt>ex.post(std::move(handler), alloc)</tt>.
+ * @li Obtains the handler's associated executor object @c ex of type @c Ex by
+ * performing @code auto ex = get_associated_executor(handler); @endcode
  *
- * @li Returns <tt>result.get()</tt>.
+ * @li Obtains the handler's associated allocator object @c alloc by performing
+ * @code auto alloc = get_associated_allocator(handler); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
+ * @code execution::execute(
+ *     prefer(
+ *       require(ex, execution::blocking.never),
+ *       execution::relationship.fork,
+ *       execution::allocator(alloc)),
+ *     std::forward<CompletionHandler>(completion_handler)); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
+ * @code ex.post(
+ *     std::forward<CompletionHandler>(completion_handler),
+ *     alloc); @endcode
+ *
+ * @par Completion Signature
+ * @code void() @endcode
  */
-template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token);
+template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) post(
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token);
 
 /// Submits a completion token or function object for execution.
 /**
@@ -67,36 +88,76 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
  * The use of @c post(), rather than @ref defer(), indicates the caller's
  * preference that the function object be eagerly queued for execution.
  *
- * This function has the following effects:
- *
- * @li Constructs a function object handler of type @c Handler, initialized
- * with <tt>handler(forward<CompletionToken>(token))</tt>.
- *
- * @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
- * initializing the object as <tt>result(handler)</tt>.
+ * @param ex The target executor.
  *
- * @li Obtains the handler's associated executor object @c ex1 by performing
- * <tt>get_associated_executor(handler)</tt>.
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler. The function signature of the completion handler must be:
+ * @code void handler(); @endcode
  *
- * @li Creates a work object @c w by performing <tt>make_work(ex1)</tt>.
+ * @returns This function returns <tt>async_initiate<NullaryToken,
+ * void()>(Init{ex}, token)</tt>, where @c Init is a function object type
+ * defined as:
  *
- * @li Obtains the handler's associated allocator object @c alloc by performing
- * <tt>get_associated_allocator(handler)</tt>.
+ * @code class Init
+ * {
+ * public:
+ *   using executor_type = Executor;
+ *   explicit Init(const Executor& ex) : ex_(ex) {}
+ *   executor_type get_executor() const noexcept { return ex_; }
+ *   template <typename CompletionHandler>
+ *     void operator()(CompletionHandler&& completion_handler) const;
+ * private:
+ *   Executor ex_; // exposition only
+ * }; @endcode
  *
- * @li Constructs a function object @c f with a function call operator that
- * performs <tt>ex1.dispatch(std::move(handler), alloc)</tt> followed by
- * <tt>w.reset()</tt>.
+ * The function call operator of @c Init:
  *
- * @li Performs <tt>Executor(ex).post(std::move(f), alloc)</tt>.
+ * @li Obtains the handler's associated executor object @c ex1 of type @c Ex1 by
+ * performing @code auto ex1 = get_associated_executor(handler, ex); @endcode
  *
- * @li Returns <tt>result.get()</tt>.
+ * @li Obtains the handler's associated allocator object @c alloc by performing
+ * @code auto alloc = get_associated_allocator(handler); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex1>::value</tt> is true, constructs a
+ * function object @c f with a member @c executor_ that is initialised with
+ * <tt>prefer(ex1, execution::outstanding_work.tracked)</tt>, a member @c
+ * handler_ that is a decay-copy of @c completion_handler, and a function call
+ * operator that performs:
+ * @code auto a = get_associated_allocator(handler_);
+ * execution::execute(
+ *     prefer(executor_,
+ *       execution::blocking.possibly,
+ *       execution::allocator(a)),
+ *     std::move(handler_)); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex1>::value</tt> is false, constructs a
+ * function object @c f with a member @c work_ that is initialised with
+ * <tt>make_work_guard(ex1)</tt>, a member @c handler_ that is a decay-copy of
+ * @c completion_handler, and a function call operator that performs:
+ * @code auto a = get_associated_allocator(handler_);
+ * work_.get_executor().dispatch(std::move(handler_), a);
+ * work_.reset(); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
+ * @code execution::execute(
+ *     prefer(
+ *       require(ex, execution::blocking.never),
+ *       execution::relationship.fork,
+ *       execution::allocator(alloc)),
+ *     std::move(f)); @endcode
+ *
+ * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
+ * @code ex.post(std::move(f), alloc); @endcode
+ *
+ * @par Completion Signature
+ * @code void() @endcode
  */
 template <typename Executor,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) post(
     const Executor& ex,
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
     typename constraint<
       execution::is_executor<Executor>::value || is_executor<Executor>::value
@@ -104,15 +165,24 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
 
 /// Submits a completion token or function object for execution.
 /**
- * @returns <tt>post(ctx.get_executor(), forward<CompletionToken>(token))</tt>.
+ * @param ctx An execution context, from which the target executor is obtained.
+ *
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler. The function signature of the completion handler must be:
+ * @code void handler(); @endcode
+ *
+ * @returns <tt>post(ctx.get_executor(), forward<NullaryToken>(token))</tt>.
+ *
+ * @par Completion Signature
+ * @code void() @endcode
  */
 template <typename ExecutionContext,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
         typename ExecutionContext::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) post(
     ExecutionContext& ctx,
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename ExecutionContext::executor_type),
     typename constraint<is_convertible<
diff --git a/boost/asio/prefer.hpp b/boost/asio/prefer.hpp
index 80a3589508c4c035e11ba19437bc0af6529fa12c..d6d4338fab7b01742ba3a2f1c6558fac0d014e26 100644
--- a/boost/asio/prefer.hpp
+++ b/boost/asio/prefer.hpp
@@ -2,7 +2,7 @@
 // prefer.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -118,7 +118,7 @@ struct prefer_result
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_prefer_fn {
+namespace boost_asio_prefer_fn {
 
 using boost::asio::conditional;
 using boost::asio::decay;
@@ -566,26 +566,26 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_prefer_fn
+} // namespace boost_asio_prefer_fn
 namespace boost {
 namespace asio {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_prefer_fn::impl&
-  prefer = asio_prefer_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_prefer_fn::impl&
+  prefer = boost_asio_prefer_fn::static_instance<>::instance;
 
 } // namespace
 
-typedef asio_prefer_fn::impl prefer_t;
+typedef boost_asio_prefer_fn::impl prefer_t;
 
 #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename T, typename... Properties>
 struct can_prefer :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<
+    boost_asio_prefer_fn::call_traits<
       prefer_t, T, void(Properties...)>::overload
-        != asio_prefer_fn::ill_formed>
+        != boost_asio_prefer_fn::ill_formed>
 {
 };
 
@@ -595,27 +595,27 @@ template <typename T, typename P0 = void,
     typename P1 = void, typename P2 = void>
 struct can_prefer :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<
+    boost_asio_prefer_fn::call_traits<
       prefer_t, T, void(P0, P1, P2)>::overload
-        != asio_prefer_fn::ill_formed>
+        != boost_asio_prefer_fn::ill_formed>
 {
 };
 
 template <typename T, typename P0, typename P1>
 struct can_prefer<T, P0, P1> :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<
+    boost_asio_prefer_fn::call_traits<
       prefer_t, T, void(P0, P1)>::overload
-        != asio_prefer_fn::ill_formed>
+        != boost_asio_prefer_fn::ill_formed>
 {
 };
 
 template <typename T, typename P0>
 struct can_prefer<T, P0> :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<
+    boost_asio_prefer_fn::call_traits<
       prefer_t, T, void(P0)>::overload
-        != asio_prefer_fn::ill_formed>
+        != boost_asio_prefer_fn::ill_formed>
 {
 };
 
@@ -640,7 +640,7 @@ constexpr bool can_prefer_v
 template <typename T, typename... Properties>
 struct is_nothrow_prefer :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<
+    boost_asio_prefer_fn::call_traits<
       prefer_t, T, void(Properties...)>::is_noexcept>
 {
 };
@@ -651,7 +651,7 @@ template <typename T, typename P0 = void,
     typename P1 = void, typename P2 = void>
 struct is_nothrow_prefer :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<
+    boost_asio_prefer_fn::call_traits<
       prefer_t, T, void(P0, P1, P2)>::is_noexcept>
 {
 };
@@ -659,7 +659,7 @@ struct is_nothrow_prefer :
 template <typename T, typename P0, typename P1>
 struct is_nothrow_prefer<T, P0, P1> :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<
+    boost_asio_prefer_fn::call_traits<
       prefer_t, T, void(P0, P1)>::is_noexcept>
 {
 };
@@ -667,7 +667,7 @@ struct is_nothrow_prefer<T, P0, P1> :
 template <typename T, typename P0>
 struct is_nothrow_prefer<T, P0> :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<
+    boost_asio_prefer_fn::call_traits<
       prefer_t, T, void(P0)>::is_noexcept>
 {
 };
@@ -693,7 +693,7 @@ constexpr bool is_nothrow_prefer_v
 template <typename T, typename... Properties>
 struct prefer_result
 {
-  typedef typename asio_prefer_fn::call_traits<
+  typedef typename boost_asio_prefer_fn::call_traits<
       prefer_t, T, void(Properties...)>::result_type type;
 };
 
@@ -703,21 +703,21 @@ template <typename T, typename P0 = void,
     typename P1 = void, typename P2 = void>
 struct prefer_result
 {
-  typedef typename asio_prefer_fn::call_traits<
+  typedef typename boost_asio_prefer_fn::call_traits<
       prefer_t, T, void(P0, P1, P2)>::result_type type;
 };
 
 template <typename T, typename P0, typename P1>
 struct prefer_result<T, P0, P1>
 {
-  typedef typename asio_prefer_fn::call_traits<
+  typedef typename boost_asio_prefer_fn::call_traits<
       prefer_t, T, void(P0, P1)>::result_type type;
 };
 
 template <typename T, typename P0>
 struct prefer_result<T, P0>
 {
-  typedef typename asio_prefer_fn::call_traits<
+  typedef typename boost_asio_prefer_fn::call_traits<
       prefer_t, T, void(P0)>::result_type type;
 };
 
diff --git a/boost/asio/query.hpp b/boost/asio/query.hpp
index d742bc2d6f8d0d80ca0322fb5713ab5cdf965eea..1f71fba0611245213b80263545de47ba22000844 100644
--- a/boost/asio/query.hpp
+++ b/boost/asio/query.hpp
@@ -2,7 +2,7 @@
 // query.hpp
 // ~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -100,7 +100,7 @@ struct query_result
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_query_fn {
+namespace boost_asio_query_fn {
 
 using boost::asio::conditional;
 using boost::asio::decay;
@@ -268,23 +268,23 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_query_fn
+} // namespace boost_asio_query_fn
 namespace boost {
 namespace asio {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_query_fn::impl&
-  query = asio_query_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_query_fn::impl&
+  query = boost_asio_query_fn::static_instance<>::instance;
 
 } // namespace
 
-typedef asio_query_fn::impl query_t;
+typedef boost_asio_query_fn::impl query_t;
 
 template <typename T, typename Property>
 struct can_query :
   integral_constant<bool,
-    asio_query_fn::call_traits<query_t, T, void(Property)>::overload !=
-      asio_query_fn::ill_formed>
+    boost_asio_query_fn::call_traits<query_t, T, void(Property)>::overload !=
+      boost_asio_query_fn::ill_formed>
 {
 };
 
@@ -299,7 +299,7 @@ constexpr bool can_query_v
 template <typename T, typename Property>
 struct is_nothrow_query :
   integral_constant<bool,
-    asio_query_fn::call_traits<query_t, T, void(Property)>::is_noexcept>
+    boost_asio_query_fn::call_traits<query_t, T, void(Property)>::is_noexcept>
 {
 };
 
@@ -314,7 +314,7 @@ constexpr bool is_nothrow_query_v
 template <typename T, typename Property>
 struct query_result
 {
-  typedef typename asio_query_fn::call_traits<
+  typedef typename boost_asio_query_fn::call_traits<
       query_t, T, void(Property)>::result_type type;
 };
 
diff --git a/boost/asio/random_access_file.hpp b/boost/asio/random_access_file.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..20fdc9a5cc418ebf8b70043437a4964e9f764029
--- /dev/null
+++ b/boost/asio/random_access_file.hpp
@@ -0,0 +1,37 @@
+//
+// random_access_file.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_RANDOM_ACCESS_FILE_HPP
+#define BOOST_ASIO_RANDOM_ACCESS_FILE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_FILE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <boost/asio/basic_random_access_file.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Typedef for the typical usage of a random-access file.
+typedef basic_random_access_file<> random_access_file;
+
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_RANDOM_ACCESS_FILE_HPP
diff --git a/boost/asio/read.hpp b/boost/asio/read.hpp
index 0bd731a7769d4e8293d2635d3d2c89f7cfd1d5a3..138ecc8991cc38f55c57d78f94686b7b74835f7e 100644
--- a/boost/asio/read.hpp
+++ b/boost/asio/read.hpp
@@ -2,7 +2,7 @@
 // read.hpp
 // ~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -712,9 +712,9 @@ std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
 /// stream.
 /**
  * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions is
- * true:
+ * data from a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The supplied buffers are full. That is, the bytes transferred is equal to
  * the sum of the buffer sizes.
@@ -734,25 +734,30 @@ std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
  * of the buffer sizes indicates the maximum number of bytes to read from the
  * stream. Although the buffers object may be copied as necessary, ownership of
  * the underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes copied into the
- *                                           // buffers. If an error occurred,
- *                                           // this will be the  number of
- *                                           // bytes successfully transferred
- *                                           // prior to the error.
+ *   // Number of bytes copied into the buffers. If an error
+ *   // occurred, this will be the number of bytes successfully
+ *   // transferred prior to the error.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
  * @code
@@ -767,16 +772,27 @@ std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
  *     s, buffers,
  *     boost::asio::transfer_all(),
  *     handler); @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename MutableBufferSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
@@ -787,9 +803,9 @@ async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
 /// stream.
 /**
  * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions is
- * true:
+ * data from a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The supplied buffers are full. That is, the bytes transferred is equal to
  * the sum of the buffer sizes.
@@ -803,7 +819,7 @@ async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
  * of the buffer sizes indicates the maximum number of bytes to read from the
  * stream. Although the buffers object may be copied as necessary, ownership of
  * the underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
@@ -819,23 +835,28 @@ async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
  * return value indicates the maximum number of bytes to be read on the next
  * call to the stream's async_read_some function.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes copied into the
- *                                           // buffers. If an error occurred,
- *                                           // this will be the  number of
- *                                           // bytes successfully transferred
- *                                           // prior to the error.
+ *   // Number of bytes copied into the buffers. If an error
+ *   // occurred, this will be the number of bytes successfully
+ *   // transferred prior to the error.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::async_read(s,
@@ -845,18 +866,29 @@ async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
  * See the @ref buffer documentation for information on reading into multiple
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream,
     typename MutableBufferSequence, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
@@ -869,9 +901,9 @@ async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
 /// stream.
 /**
  * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions is
- * true:
+ * data from a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The specified dynamic buffer sequence is full (that is, it has reached
  * maximum size).
@@ -890,41 +922,57 @@ async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
  * @param buffers The dynamic buffer sequence into which the data will be read.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes copied into the
- *                                           // buffers. If an error occurred,
- *                                           // this will be the  number of
- *                                           // bytes successfully transferred
- *                                           // prior to the error.
+ *   // Number of bytes copied into the buffers. If an error
+ *   // occurred, this will be the number of bytes successfully
+ *   // transferred prior to the error.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note This overload is equivalent to calling:
  * @code boost::asio::async_read(
  *     s, buffers,
  *     boost::asio::transfer_all(),
  *     handler); @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename DynamicBuffer_v1,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
@@ -938,9 +986,9 @@ async_read(AsyncReadStream& s,
 /// stream.
 /**
  * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions is
- * true:
+ * data from a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The specified dynamic buffer sequence is full (that is, it has reached
  * maximum size).
@@ -959,7 +1007,7 @@ async_read(AsyncReadStream& s,
  * @param buffers The dynamic buffer sequence into which the data will be read.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
@@ -975,35 +1023,51 @@ async_read(AsyncReadStream& s,
  * return value indicates the maximum number of bytes to be read on the next
  * call to the stream's async_read_some function.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes copied into the
- *                                           // buffers. If an error occurred,
- *                                           // this will be the  number of
- *                                           // bytes successfully transferred
- *                                           // prior to the error.
+ *   // Number of bytes copied into the buffers. If an error
+ *   // occurred, this will be the number of bytes successfully
+ *   // transferred prior to the error.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
+ *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream,
     typename DynamicBuffer_v1, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
@@ -1020,9 +1084,9 @@ async_read(AsyncReadStream& s,
 /// stream.
 /**
  * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions is
- * true:
+ * data from a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The supplied buffer is full (that is, it has reached maximum size).
  *
@@ -1039,40 +1103,56 @@ async_read(AsyncReadStream& s,
  *
  * @param b A basic_streambuf object into which the data will be read. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the handler is called.
+ * remains valid until the completion handler is called.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes copied into the
- *                                           // buffers. If an error occurred,
- *                                           // this will be the  number of
- *                                           // bytes successfully transferred
- *                                           // prior to the error.
+ *   // Number of bytes copied into the buffers. If an error
+ *   // occurred, this will be the number of bytes successfully
+ *   // transferred prior to the error.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note This overload is equivalent to calling:
  * @code boost::asio::async_read(
  *     s, b,
  *     boost::asio::transfer_all(),
  *     handler); @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type));
 
@@ -1080,9 +1160,9 @@ async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
 /// stream.
 /**
  * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions is
- * true:
+ * data from a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The supplied buffer is full (that is, it has reached maximum size).
  *
@@ -1099,7 +1179,7 @@ async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
  *
  * @param b A basic_streambuf object into which the data will be read. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the handler is called.
+ * remains valid until the completion handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
@@ -1115,34 +1195,50 @@ async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
  * return value indicates the maximum number of bytes to be read on the next
  * call to the stream's async_read_some function.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes copied into the
- *                                           // buffers. If an error occurred,
- *                                           // this will be the  number of
- *                                           // bytes successfully transferred
- *                                           // prior to the error.
+ *   // Number of bytes copied into the buffers. If an error
+ *   // occurred, this will be the number of bytes successfully
+ *   // transferred prior to the error.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
+ *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream,
     typename Allocator, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type));
 
@@ -1154,9 +1250,9 @@ async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
 /// stream.
 /**
  * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions is
- * true:
+ * data from a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The specified dynamic buffer sequence is full (that is, it has reached
  * maximum size).
@@ -1175,40 +1271,56 @@ async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
  * @param buffers The dynamic buffer sequence into which the data will be read.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes copied into the
- *                                           // buffers. If an error occurred,
- *                                           // this will be the  number of
- *                                           // bytes successfully transferred
- *                                           // prior to the error.
+ *   // Number of bytes copied into the buffers. If an error
+ *   // occurred, this will be the number of bytes successfully
+ *   // transferred prior to the error.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note This overload is equivalent to calling:
  * @code boost::asio::async_read(
  *     s, buffers,
  *     boost::asio::transfer_all(),
  *     handler); @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename DynamicBuffer_v2,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
@@ -1219,9 +1331,9 @@ async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
 /// stream.
 /**
  * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions is
- * true:
+ * data from a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The specified dynamic buffer sequence is full (that is, it has reached
  * maximum size).
@@ -1240,7 +1352,7 @@ async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
  * @param buffers The dynamic buffer sequence into which the data will be read.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
@@ -1256,34 +1368,50 @@ async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
  * return value indicates the maximum number of bytes to be read on the next
  * call to the stream's async_read_some function.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes copied into the
- *                                           // buffers. If an error occurred,
- *                                           // this will be the  number of
- *                                           // bytes successfully transferred
- *                                           // prior to the error.
+ *   // Number of bytes copied into the buffers. If an error
+ *   // occurred, this will be the number of bytes successfully
+ *   // transferred prior to the error.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
+ *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream,
     typename DynamicBuffer_v2, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
diff --git a/boost/asio/read_at.hpp b/boost/asio/read_at.hpp
index 920c3c30c0ea34d7df6585e02bd9fd3332889a50..56d8555553bb5b87d5af0890b878cd39181fdfd7 100644
--- a/boost/asio/read_at.hpp
+++ b/boost/asio/read_at.hpp
@@ -2,7 +2,7 @@
 // read_at.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -404,9 +404,10 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
 /// specified offset.
 /**
  * This function is used to asynchronously read a certain number of bytes of
- * data from a random access device at the specified offset. The function call
- * always returns immediately. The asynchronous operation will continue until
- * one of the following conditions is true:
+ * data from a random access device at the specified offset. It is an
+ * initiating function for an @ref asynchronous_operation, and always returns
+ * immediately. The asynchronous operation will continue until one of the
+ * following conditions is true:
  *
  * @li The supplied buffers are full. That is, the bytes transferred is equal to
  * the sum of the buffer sizes.
@@ -425,11 +426,13 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  * of the buffer sizes indicates the maximum number of bytes to read from the
  * device. Although the buffers object may be copied as necessary, ownership of
  * the underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -440,10 +443,13 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
  * @code
@@ -458,17 +464,28 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  *     d, 42, buffers,
  *     boost::asio::transfer_all(),
  *     handler); @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncRandomAccessReadDevice type's
+ * async_read_some_at operation.
  */
 template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncRandomAccessReadDevice::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
     const MutableBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncRandomAccessReadDevice::executor_type));
 
@@ -476,9 +493,10 @@ async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
 /// specified offset.
 /**
  * This function is used to asynchronously read a certain number of bytes of
- * data from a random access device at the specified offset. The function call
- * always returns immediately. The asynchronous operation will continue until
- * one of the following conditions is true:
+ * data from a random access device at the specified offset. It is an
+ * initiating function for an @ref asynchronous_operation, and always returns
+ * immediately. The asynchronous operation will continue until one of the
+ * following conditions is true:
  *
  * @li The supplied buffers are full. That is, the bytes transferred is equal to
  * the sum of the buffer sizes.
@@ -494,7 +512,7 @@ async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
  * of the buffer sizes indicates the maximum number of bytes to read from the
  * device. Although the buffers object may be copied as necessary, ownership of
  * the underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
@@ -510,9 +528,11 @@ async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
  * return value indicates the maximum number of bytes to be read on the next
  * call to the device's async_read_some_at function.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -523,10 +543,13 @@ async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::async_read_at(d, 42,
@@ -536,19 +559,30 @@ async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
  * See the @ref buffer documentation for information on reading into multiple
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncRandomAccessReadDevice type's
+ * async_read_some_at operation.
  */
 template <typename AsyncRandomAccessReadDevice,
     typename MutableBufferSequence, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncRandomAccessReadDevice::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncRandomAccessReadDevice::executor_type));
 
@@ -559,9 +593,10 @@ async_read_at(AsyncRandomAccessReadDevice& d,
 /// specified offset.
 /**
  * This function is used to asynchronously read a certain number of bytes of
- * data from a random access device at the specified offset. The function call
- * always returns immediately. The asynchronous operation will continue until
- * one of the following conditions is true:
+ * data from a random access device at the specified offset. It is an
+ * initiating function for an @ref asynchronous_operation, and always returns
+ * immediately. The asynchronous operation will continue until one of the
+ * following conditions is true:
  *
  * @li An error occurred.
  *
@@ -575,11 +610,13 @@ async_read_at(AsyncRandomAccessReadDevice& d,
  *
  * @param b A basic_streambuf object into which the data will be read. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the handler is called.
+ * remains valid until the completion handler is called.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -590,26 +627,40 @@ async_read_at(AsyncRandomAccessReadDevice& d,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note This overload is equivalent to calling:
  * @code boost::asio::async_read_at(
  *     d, 42, b,
  *     boost::asio::transfer_all(),
  *     handler); @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncRandomAccessReadDevice type's
+ * async_read_some_at operation.
  */
 template <typename AsyncRandomAccessReadDevice, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncRandomAccessReadDevice::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, basic_streambuf<Allocator>& b,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncRandomAccessReadDevice::executor_type));
 
@@ -617,9 +668,10 @@ async_read_at(AsyncRandomAccessReadDevice& d,
 /// specified offset.
 /**
  * This function is used to asynchronously read a certain number of bytes of
- * data from a random access device at the specified offset. The function call
- * always returns immediately. The asynchronous operation will continue until
- * one of the following conditions is true:
+ * data from a random access device at the specified offset. It is an
+ * initiating function for an @ref asynchronous_operation, and always returns
+ * immediately. The asynchronous operation will continue until one of the
+ * following conditions is true:
  *
  * @li The completion_condition function object returns 0.
  *
@@ -633,7 +685,7 @@ async_read_at(AsyncRandomAccessReadDevice& d,
  *
  * @param b A basic_streambuf object into which the data will be read. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the handler is called.
+ * remains valid until the completion handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
@@ -649,9 +701,11 @@ async_read_at(AsyncRandomAccessReadDevice& d,
  * return value indicates the maximum number of bytes to be read on the next
  * call to the device's async_read_some_at function.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -662,22 +716,36 @@ async_read_at(AsyncRandomAccessReadDevice& d,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
+ *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncRandomAccessReadDevice type's
+ * async_read_some_at operation.
  */
 template <typename AsyncRandomAccessReadDevice,
     typename Allocator, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncRandomAccessReadDevice::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncRandomAccessReadDevice::executor_type));
 
diff --git a/boost/asio/read_until.hpp b/boost/asio/read_until.hpp
index 69b7bcfc7aafb231fb911d5eac34e6f32ff8c513..ca5e1babde79565e2d9d6ec93c5d3493c64f81ed 100644
--- a/boost/asio/read_until.hpp
+++ b/boost/asio/read_until.hpp
@@ -2,7 +2,7 @@
 // read_until.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -1546,9 +1546,9 @@ std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
 /**
  * This function is used to asynchronously read data into the specified dynamic
  * buffer sequence until the dynamic buffer sequence's get area contains the
- * specified delimiter. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * specified delimiter. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The get area of the dynamic buffer sequence contains the specified
  * delimiter.
@@ -1569,27 +1569,31 @@ std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
  * @param buffers The dynamic buffer sequence into which the data will be read.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param delim The delimiter character.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
  *
  *   // The number of bytes in the dynamic buffer sequence's
  *   // get area up to and including the delimiter.
- *   // 0 if an error occurred.
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note After a successful async_read_until operation, the dynamic buffer
  * sequence may contain additional data beyond the delimiter. An application
  * will typically leave that data in the dynamic buffer sequence for a
@@ -1622,17 +1626,28 @@ std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c async_read_until operation.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename DynamicBuffer_v1,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers, char delim,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
@@ -1647,9 +1662,9 @@ async_read_until(AsyncReadStream& s,
 /**
  * This function is used to asynchronously read data into the specified dynamic
  * buffer sequence until the dynamic buffer sequence's get area contains the
- * specified delimiter. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * specified delimiter. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The get area of the dynamic buffer sequence contains the specified
  * delimiter.
@@ -1670,27 +1685,31 @@ async_read_until(AsyncReadStream& s,
  * @param buffers The dynamic buffer sequence into which the data will be read.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param delim The delimiter string.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
  *
  *   // The number of bytes in the dynamic buffer sequence's
  *   // get area up to and including the delimiter.
- *   // 0 if an error occurred.
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note After a successful async_read_until operation, the dynamic buffer
  * sequence may contain additional data beyond the delimiter. An application
  * will typically leave that data in the dynamic buffer sequence for a
@@ -1723,18 +1742,29 @@ async_read_until(AsyncReadStream& s,
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c async_read_until operation.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename DynamicBuffer_v1,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
     BOOST_ASIO_STRING_VIEW_PARAM delim,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
@@ -1753,9 +1783,10 @@ async_read_until(AsyncReadStream& s,
 /**
  * This function is used to asynchronously read data into the specified dynamic
  * buffer sequence until the dynamic buffer sequence's get area contains some
- * data that matches a regular expression. The function call always returns
- * immediately. The asynchronous operation will continue until one of the
- * following conditions is true:
+ * data that matches a regular expression. It is an initiating function for an
+ * @ref asynchronous_operation, and always returns immediately. The
+ * asynchronous operation will continue until one of the following conditions
+ * is true:
  *
  * @li A substring of the dynamic buffer sequence's get area matches the regular
  * expression.
@@ -1777,13 +1808,15 @@ async_read_until(AsyncReadStream& s,
  * @param buffers The dynamic buffer sequence into which the data will be read.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param expr The regular expression.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -1795,10 +1828,13 @@ async_read_until(AsyncReadStream& s,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note After a successful async_read_until operation, the dynamic buffer
  * sequence may contain additional data beyond that which matched the regular
  * expression. An application will typically leave that data in the dynamic
@@ -1832,18 +1868,29 @@ async_read_until(AsyncReadStream& s,
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c async_read_until operation.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename DynamicBuffer_v1,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
     const boost::regex& expr,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
@@ -1862,9 +1909,9 @@ async_read_until(AsyncReadStream& s,
  * This function is used to asynchronously read data into the specified dynamic
  * buffer sequence until a user-defined match condition function object, when
  * applied to the data contained in the dynamic buffer sequence, indicates a
- * successful match. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * successful match. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The match condition function object returns a std::pair where the second
  * element evaluates to true.
@@ -1885,7 +1932,7 @@ async_read_until(AsyncReadStream& s,
  * @param buffers The dynamic buffer sequence into which the data will be read.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param match_condition The function object to be called to determine whether
  * a match exists. The signature of the function object must be:
@@ -1902,9 +1949,11 @@ async_read_until(AsyncReadStream& s,
  * @c second member of the return value is true if a match has been found, false
  * otherwise.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -1915,8 +1964,8 @@ async_read_until(AsyncReadStream& s,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
  * @note After a successful async_read_until operation, the dynamic buffer
@@ -1924,6 +1973,9 @@ async_read_until(AsyncReadStream& s,
  * object. An application will typically leave that data in the dynamic buffer
  * sequence for a subsequent async_read_until operation to examine.
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note The default implementation of the @c is_match_condition type trait
  * evaluates to true for function pointers and function objects with a
  * @c result_type typedef. It must be specialised for other user-defined
@@ -1983,19 +2035,30 @@ async_read_until(AsyncReadStream& s,
  * std::string data;
  * boost::asio::async_read_until(s, data, match_char('a'), handler);
  * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream,
     typename DynamicBuffer_v1, typename MatchCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
     MatchCondition match_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
@@ -2015,8 +2078,9 @@ async_read_until(AsyncReadStream& s,
 /**
  * This function is used to asynchronously read data into the specified
  * streambuf until the streambuf's get area contains the specified delimiter.
- * The function call always returns immediately. The asynchronous operation
- * will continue until one of the following conditions is true:
+ * It is an initiating function for an @ref asynchronous_operation, and always
+ * returns immediately. The asynchronous operation will continue until one of
+ * the following conditions is true:
  *
  * @li The get area of the streambuf contains the specified delimiter.
  *
@@ -2035,13 +2099,15 @@ async_read_until(AsyncReadStream& s,
  *
  * @param b A streambuf object into which the data will be read. Ownership of
  * the streambuf is retained by the caller, which must guarantee that it remains
- * valid until the handler is called.
+ * valid until the completion handler is called.
  *
  * @param delim The delimiter character.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -2052,10 +2118,13 @@ async_read_until(AsyncReadStream& s,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note After a successful async_read_until operation, the streambuf may
  * contain additional data beyond the delimiter. An application will typically
  * leave that data in the streambuf for a subsequent async_read_until operation
@@ -2087,17 +2156,28 @@ async_read_until(AsyncReadStream& s,
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c async_read_until operation.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, char delim,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type));
 
@@ -2106,8 +2186,9 @@ async_read_until(AsyncReadStream& s,
 /**
  * This function is used to asynchronously read data into the specified
  * streambuf until the streambuf's get area contains the specified delimiter.
- * The function call always returns immediately. The asynchronous operation
- * will continue until one of the following conditions is true:
+ * It is an initiating function for an @ref asynchronous_operation, and always
+ * returns immediately. The asynchronous operation will continue until one of
+ * the following conditions is true:
  *
  * @li The get area of the streambuf contains the specified delimiter.
  *
@@ -2126,13 +2207,15 @@ async_read_until(AsyncReadStream& s,
  *
  * @param b A streambuf object into which the data will be read. Ownership of
  * the streambuf is retained by the caller, which must guarantee that it remains
- * valid until the handler is called.
+ * valid until the completion handler is called.
  *
  * @param delim The delimiter string.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -2143,10 +2226,13 @@ async_read_until(AsyncReadStream& s,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note After a successful async_read_until operation, the streambuf may
  * contain additional data beyond the delimiter. An application will typically
  * leave that data in the streambuf for a subsequent async_read_until operation
@@ -2178,18 +2264,29 @@ async_read_until(AsyncReadStream& s,
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c async_read_until operation.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     BOOST_ASIO_STRING_VIEW_PARAM delim,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type));
 
@@ -2201,9 +2298,9 @@ async_read_until(AsyncReadStream& s,
 /**
  * This function is used to asynchronously read data into the specified
  * streambuf until the streambuf's get area contains some data that matches a
- * regular expression. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * regular expression. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li A substring of the streambuf's get area matches the regular expression.
  *
@@ -2223,13 +2320,15 @@ async_read_until(AsyncReadStream& s,
  *
  * @param b A streambuf object into which the data will be read. Ownership of
  * the streambuf is retained by the caller, which must guarantee that it remains
- * valid until the handler is called.
+ * valid until the completion handler is called.
  *
  * @param expr The regular expression.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -2241,10 +2340,13 @@ async_read_until(AsyncReadStream& s,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note After a successful async_read_until operation, the streambuf may
  * contain additional data beyond that which matched the regular expression. An
  * application will typically leave that data in the streambuf for a subsequent
@@ -2277,17 +2379,28 @@ async_read_until(AsyncReadStream& s,
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c async_read_until operation.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type));
 
@@ -2299,9 +2412,10 @@ async_read_until(AsyncReadStream& s,
 /**
  * This function is used to asynchronously read data into the specified
  * streambuf until a user-defined match condition function object, when applied
- * to the data contained in the streambuf, indicates a successful match. The
- * function call always returns immediately. The asynchronous operation will
- * continue until one of the following conditions is true:
+ * to the data contained in the streambuf, indicates a successful match. It is
+ * an initiating function for an @ref asynchronous_operation, and always
+ * returns immediately. The asynchronous operation will continue until one of
+ * the following conditions is true:
  *
  * @li The match condition function object returns a std::pair where the second
  * element evaluates to true.
@@ -2336,9 +2450,11 @@ async_read_until(AsyncReadStream& s,
  * @c second member of the return value is true if a match has been found, false
  * otherwise.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -2349,8 +2465,8 @@ async_read_until(AsyncReadStream& s,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
  * @note After a successful async_read_until operation, the streambuf may
@@ -2358,6 +2474,9 @@ async_read_until(AsyncReadStream& s,
  * application will typically leave that data in the streambuf for a subsequent
  * async_read_until operation to examine.
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note The default implementation of the @c is_match_condition type trait
  * evaluates to true for function pointers and function objects with a
  * @c result_type typedef. It must be specialised for other user-defined
@@ -2416,18 +2535,29 @@ async_read_until(AsyncReadStream& s,
  * boost::asio::streambuf b;
  * boost::asio::async_read_until(s, b, match_char('a'), handler);
  * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename Allocator, typename MatchCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     MatchCondition match_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<is_match_condition<MatchCondition>::value>::type = 0);
@@ -2441,9 +2571,9 @@ async_read_until(AsyncReadStream& s,
 /**
  * This function is used to asynchronously read data into the specified dynamic
  * buffer sequence until the dynamic buffer sequence's get area contains the
- * specified delimiter. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * specified delimiter. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The get area of the dynamic buffer sequence contains the specified
  * delimiter.
@@ -2464,13 +2594,15 @@ async_read_until(AsyncReadStream& s,
  * @param buffers The dynamic buffer sequence into which the data will be read.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param delim The delimiter character.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -2481,10 +2613,13 @@ async_read_until(AsyncReadStream& s,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note After a successful async_read_until operation, the dynamic buffer
  * sequence may contain additional data beyond the delimiter. An application
  * will typically leave that data in the dynamic buffer sequence for a
@@ -2517,16 +2652,27 @@ async_read_until(AsyncReadStream& s,
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c async_read_until operation.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename DynamicBuffer_v2,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers, char delim,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
@@ -2538,9 +2684,9 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers, char delim,
 /**
  * This function is used to asynchronously read data into the specified dynamic
  * buffer sequence until the dynamic buffer sequence's get area contains the
- * specified delimiter. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * specified delimiter. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The get area of the dynamic buffer sequence contains the specified
  * delimiter.
@@ -2561,27 +2707,31 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers, char delim,
  * @param buffers The dynamic buffer sequence into which the data will be read.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param delim The delimiter string.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
  *
  *   // The number of bytes in the dynamic buffer sequence's
  *   // get area up to and including the delimiter.
- *   // 0 if an error occurred.
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note After a successful async_read_until operation, the dynamic buffer
  * sequence may contain additional data beyond the delimiter. An application
  * will typically leave that data in the dynamic buffer sequence for a
@@ -2614,17 +2764,28 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers, char delim,
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c async_read_until operation.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename DynamicBuffer_v2,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
     BOOST_ASIO_STRING_VIEW_PARAM delim,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
@@ -2640,9 +2801,10 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
 /**
  * This function is used to asynchronously read data into the specified dynamic
  * buffer sequence until the dynamic buffer sequence's get area contains some
- * data that matches a regular expression. The function call always returns
- * immediately. The asynchronous operation will continue until one of the
- * following conditions is true:
+ * data that matches a regular expression. It is an initiating function for an
+ * @ref asynchronous_operation, and always returns immediately. The
+ * asynchronous operation will continue until one of the following conditions
+ * is true:
  *
  * @li A substring of the dynamic buffer sequence's get area matches the regular
  * expression.
@@ -2664,13 +2826,15 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
  * @param buffers The dynamic buffer sequence into which the data will be read.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param expr The regular expression.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -2682,10 +2846,13 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note After a successful async_read_until operation, the dynamic buffer
  * sequence may contain additional data beyond that which matched the regular
  * expression. An application will typically leave that data in the dynamic
@@ -2719,17 +2886,28 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c async_read_until operation.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream, typename DynamicBuffer_v2,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
     const boost::regex& expr,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
@@ -2745,9 +2923,9 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
  * This function is used to asynchronously read data into the specified dynamic
  * buffer sequence until a user-defined match condition function object, when
  * applied to the data contained in the dynamic buffer sequence, indicates a
- * successful match. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * successful match. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li The match condition function object returns a std::pair where the second
  * element evaluates to true.
@@ -2768,7 +2946,7 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
  * @param buffers The dynamic buffer sequence into which the data will be read.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param match_condition The function object to be called to determine whether
  * a match exists. The signature of the function object must be:
@@ -2785,9 +2963,11 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
  * @c second member of the return value is true if a match has been found, false
  * otherwise.
  *
- * @param handler The handler to be called when the read operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the read completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -2798,8 +2978,8 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
  * @note After a successful async_read_until operation, the dynamic buffer
@@ -2807,6 +2987,9 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
  * object. An application will typically leave that data in the dynamic buffer
  * sequence for a subsequent async_read_until operation to examine.
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @note The default implementation of the @c is_match_condition type trait
  * evaluates to true for function pointers and function objects with a
  * @c result_type typedef. It must be specialised for other user-defined
@@ -2866,18 +3049,29 @@ async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
  * std::string data;
  * boost::asio::async_read_until(s, data, match_char('a'), handler);
  * @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncReadStream type's
+ * @c async_read_some operation.
  */
 template <typename AsyncReadStream,
     typename DynamicBuffer_v2, typename MatchCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) ReadHandler
+      std::size_t)) ReadToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncReadStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
     void (boost::system::error_code, std::size_t))
 async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
     MatchCondition match_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+    BOOST_ASIO_MOVE_ARG(ReadToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncReadStream::executor_type),
     typename constraint<
diff --git a/boost/asio/readable_pipe.hpp b/boost/asio/readable_pipe.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..417de3190c70efde58fd0a6c63c6be653814155e
--- /dev/null
+++ b/boost/asio/readable_pipe.hpp
@@ -0,0 +1,37 @@
+//
+// readable_pipe.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_READABLE_PIPE_HPP
+#define BOOST_ASIO_READABLE_PIPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_PIPE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <boost/asio/basic_readable_pipe.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Typedef for the typical usage of a readable pipe.
+typedef basic_readable_pipe<> readable_pipe;
+
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_ASIO_HAS_PIPE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_READABLE_PIPE_HPP
diff --git a/boost/asio/recycling_allocator.hpp b/boost/asio/recycling_allocator.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..bc12612ac872da325b57d87a67dd4e1282e265d4
--- /dev/null
+++ b/boost/asio/recycling_allocator.hpp
@@ -0,0 +1,140 @@
+//
+// recycling_allocator.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_RECYCLING_ALLOCATOR_HPP
+#define BOOST_ASIO_RECYCLING_ALLOCATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/recycling_allocator.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// An allocator that caches memory blocks in thread-local storage for reuse.
+/**
+ * The @recycling_allocator uses a simple strategy where a limited number of
+ * small memory blocks are cached in thread-local storage, if the current
+ * thread is running an @c io_context or is part of a @c thread_pool.
+ */
+template <typename T>
+class recycling_allocator
+{
+public:
+  /// The type of object allocated by the recycling allocator.
+  typedef T value_type;
+
+  /// Rebind the allocator to another value_type.
+  template <typename U>
+  struct rebind
+  {
+    /// The rebound @c allocator type.
+    typedef recycling_allocator<U> other;
+  };
+
+  /// Default constructor.
+  BOOST_ASIO_CONSTEXPR recycling_allocator() BOOST_ASIO_NOEXCEPT
+  {
+  }
+
+  /// Converting constructor.
+  template <typename U>
+  BOOST_ASIO_CONSTEXPR recycling_allocator(
+      const recycling_allocator<U>&) BOOST_ASIO_NOEXCEPT
+  {
+  }
+
+  /// Equality operator. Always returns true.
+  BOOST_ASIO_CONSTEXPR bool operator==(
+      const recycling_allocator&) const BOOST_ASIO_NOEXCEPT
+  {
+    return true;
+  }
+
+  /// Inequality operator. Always returns false.
+  BOOST_ASIO_CONSTEXPR bool operator!=(
+      const recycling_allocator&) const BOOST_ASIO_NOEXCEPT
+  {
+    return false;
+  }
+
+  /// Allocate memory for the specified number of values.
+  T* allocate(std::size_t n)
+  {
+    return detail::recycling_allocator<T>().allocate(n);
+  }
+
+  /// Deallocate memory for the specified number of values.
+  void deallocate(T* p, std::size_t n)
+  {
+    detail::recycling_allocator<T>().deallocate(p, n);
+  }
+};
+
+/// A proto-allocator that caches memory blocks in thread-local storage for
+/// reuse.
+/**
+ * The @recycling_allocator uses a simple strategy where a limited number of
+ * small memory blocks are cached in thread-local storage, if the current
+ * thread is running an @c io_context or is part of a @c thread_pool.
+ */
+template <>
+class recycling_allocator<void>
+{
+public:
+  /// No values are allocated by a proto-allocator.
+  typedef void value_type;
+
+  /// Rebind the allocator to another value_type.
+  template <typename U>
+  struct rebind
+  {
+    /// The rebound @c allocator type.
+    typedef recycling_allocator<U> other;
+  };
+
+  /// Default constructor.
+  BOOST_ASIO_CONSTEXPR recycling_allocator() BOOST_ASIO_NOEXCEPT
+  {
+  }
+
+  /// Converting constructor.
+  template <typename U>
+  BOOST_ASIO_CONSTEXPR recycling_allocator(
+      const recycling_allocator<U>&) BOOST_ASIO_NOEXCEPT
+  {
+  }
+
+  /// Equality operator. Always returns true.
+  BOOST_ASIO_CONSTEXPR bool operator==(
+      const recycling_allocator&) const BOOST_ASIO_NOEXCEPT
+  {
+    return true;
+  }
+
+  /// Inequality operator. Always returns false.
+  BOOST_ASIO_CONSTEXPR bool operator!=(
+      const recycling_allocator&) const BOOST_ASIO_NOEXCEPT
+  {
+    return false;
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_RECYCLING_ALLOCATOR_HPP
diff --git a/boost/asio/redirect_error.hpp b/boost/asio/redirect_error.hpp
index 6da181cee58aa7f46e330e26c9c20adaffd7dc1b..f2e83a5a6d7d29d4b1cb43c96eb30dd54263d797 100644
--- a/boost/asio/redirect_error.hpp
+++ b/boost/asio/redirect_error.hpp
@@ -2,7 +2,7 @@
 // redirect_error.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/registered_buffer.hpp b/boost/asio/registered_buffer.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..028eb2d79fdf606e6a02239b126683b4544b0495
--- /dev/null
+++ b/boost/asio/registered_buffer.hpp
@@ -0,0 +1,358 @@
+//
+// registered_buffer.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_REGISTERED_BUFFER_HPP
+#define BOOST_ASIO_REGISTERED_BUFFER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/buffer.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class buffer_registration_base;
+
+} // namespace detail
+
+class const_registered_buffer;
+
+/// Type used to identify a registered buffer.
+class registered_buffer_id
+{
+public:
+  /// The native buffer identifier type.
+  typedef int native_handle_type;
+
+  /// Default constructor creates an invalid registered buffer identifier.
+  registered_buffer_id() BOOST_ASIO_NOEXCEPT
+    : scope_(0),
+      index_(-1)
+  {
+  }
+
+  /// Get the native buffer identifier type.
+  native_handle_type native_handle() const BOOST_ASIO_NOEXCEPT
+  {
+    return index_;
+  }
+
+  /// Compare two IDs for equality.
+  friend bool operator==(const registered_buffer_id& lhs,
+      const registered_buffer_id& rhs) BOOST_ASIO_NOEXCEPT
+  {
+    return lhs.scope_ == rhs.scope_ && lhs.index_ == rhs.index_;
+  }
+
+  /// Compare two IDs for equality.
+  friend bool operator!=(const registered_buffer_id& lhs,
+      const registered_buffer_id& rhs) BOOST_ASIO_NOEXCEPT
+  {
+    return lhs.scope_ != rhs.scope_ || lhs.index_ != rhs.index_;
+  }
+
+private:
+  friend class detail::buffer_registration_base;
+
+  // Hidden constructor used by buffer registration.
+  registered_buffer_id(const void* scope, int index) BOOST_ASIO_NOEXCEPT
+    : scope_(scope),
+      index_(index)
+  {
+  }
+
+  const void* scope_;
+  int index_;
+};
+
+/// Holds a registered buffer over modifiable data.
+/** 
+ * Satisfies the @c MutableBufferSequence type requirements.
+ */
+class mutable_registered_buffer
+{
+public:
+#if !defined(BOOST_ASIO_HAS_DECLTYPE) \
+  && !defined(GENERATING_DOCUMENTATION)
+  typedef mutable_buffer value_type;
+#endif // !defined(BOOST_ASIO_HAS_DECLTYPE)
+       //   && !defined(GENERATING_DOCUMENTATION)
+
+  /// Default constructor creates an invalid registered buffer.
+  mutable_registered_buffer() BOOST_ASIO_NOEXCEPT
+    : buffer_(),
+      id_()
+  {
+  }
+
+  /// Get the underlying mutable buffer.
+  const mutable_buffer& buffer() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffer_;
+  }
+
+  /// Get a pointer to the beginning of the memory range.
+  /**
+   * @returns <tt>buffer().data()</tt>.
+   */
+  void* data() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffer_.data();
+  }
+
+  /// Get the size of the memory range.
+  /**
+   * @returns <tt>buffer().size()</tt>.
+   */
+  std::size_t size() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffer_.size();
+  }
+
+  /// Get the registered buffer identifier.
+  const registered_buffer_id& id() const BOOST_ASIO_NOEXCEPT
+  {
+    return id_;
+  }
+
+  /// Move the start of the buffer by the specified number of bytes.
+  mutable_registered_buffer& operator+=(std::size_t n) BOOST_ASIO_NOEXCEPT
+  {
+    buffer_ += n;
+    return *this;
+  }
+
+private:
+  friend class detail::buffer_registration_base;
+
+  // Hidden constructor used by buffer registration and operators.
+  mutable_registered_buffer(const mutable_buffer& b,
+      const registered_buffer_id& i) BOOST_ASIO_NOEXCEPT
+    : buffer_(b),
+      id_(i)
+  {
+  }
+
+#if !defined(GENERATING_DOCUMENTATION)
+  friend mutable_registered_buffer buffer(
+      const mutable_registered_buffer& b, std::size_t n) BOOST_ASIO_NOEXCEPT;
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+  mutable_buffer buffer_;
+  registered_buffer_id id_;
+};
+
+/// Holds a registered buffer over non-modifiable data.
+/** 
+ * Satisfies the @c ConstBufferSequence type requirements.
+ */
+class const_registered_buffer
+{
+public:
+#if !defined(BOOST_ASIO_HAS_DECLTYPE) \
+  && !defined(GENERATING_DOCUMENTATION)
+  typedef const_buffer value_type;
+#endif // !defined(BOOST_ASIO_HAS_DECLTYPE)
+       //   && !defined(GENERATING_DOCUMENTATION)
+
+  /// Default constructor creates an invalid registered buffer.
+  const_registered_buffer() BOOST_ASIO_NOEXCEPT
+    : buffer_(),
+      id_()
+  {
+  }
+
+  /// Construct a non-modifiable buffer from a modifiable one.
+  const_registered_buffer(
+      const mutable_registered_buffer& b) BOOST_ASIO_NOEXCEPT
+    : buffer_(b.buffer()),
+      id_(b.id())
+  {
+  }
+
+  /// Get the underlying constant buffer.
+  const const_buffer& buffer() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffer_;
+  }
+
+  /// Get a pointer to the beginning of the memory range.
+  /**
+   * @returns <tt>buffer().data()</tt>.
+   */
+  const void* data() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffer_.data();
+  }
+
+  /// Get the size of the memory range.
+  /**
+   * @returns <tt>buffer().size()</tt>.
+   */
+  std::size_t size() const BOOST_ASIO_NOEXCEPT
+  {
+    return buffer_.size();
+  }
+
+  /// Get the registered buffer identifier.
+  const registered_buffer_id& id() const BOOST_ASIO_NOEXCEPT
+  {
+    return id_;
+  }
+
+  /// Move the start of the buffer by the specified number of bytes.
+  const_registered_buffer& operator+=(std::size_t n) BOOST_ASIO_NOEXCEPT
+  {
+    buffer_ += n;
+    return *this;
+  }
+
+private:
+  // Hidden constructor used by operators.
+  const_registered_buffer(const const_buffer& b,
+      const registered_buffer_id& i) BOOST_ASIO_NOEXCEPT
+    : buffer_(b),
+      id_(i)
+  {
+  }
+
+#if !defined(GENERATING_DOCUMENTATION)
+  friend const_registered_buffer buffer(
+      const const_registered_buffer& b, std::size_t n) BOOST_ASIO_NOEXCEPT;
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+  const_buffer buffer_;
+  registered_buffer_id id_;
+};
+
+/** @addtogroup buffer_sequence_begin */
+
+/// Get an iterator to the first element in a buffer sequence.
+inline const mutable_buffer* buffer_sequence_begin(
+    const mutable_registered_buffer& b) BOOST_ASIO_NOEXCEPT
+{
+  return &b.buffer();
+}
+
+/// Get an iterator to the first element in a buffer sequence.
+inline const const_buffer* buffer_sequence_begin(
+    const const_registered_buffer& b) BOOST_ASIO_NOEXCEPT
+{
+  return &b.buffer();
+}
+
+/** @} */
+/** @addtogroup buffer_sequence_end */
+
+/// Get an iterator to one past the end element in a buffer sequence.
+inline const mutable_buffer* buffer_sequence_end(
+    const mutable_registered_buffer& b) BOOST_ASIO_NOEXCEPT
+{
+  return &b.buffer() + 1;
+}
+
+/// Get an iterator to one past the end element in a buffer sequence.
+inline const const_buffer* buffer_sequence_end(
+    const const_registered_buffer& b) BOOST_ASIO_NOEXCEPT
+{
+  return &b.buffer() + 1;
+}
+
+/** @} */
+/** @addtogroup buffer */
+
+/// Obtain a buffer representing the entire registered buffer.
+inline mutable_registered_buffer buffer(
+    const mutable_registered_buffer& b) BOOST_ASIO_NOEXCEPT
+{
+  return b;
+}
+
+/// Obtain a buffer representing the entire registered buffer.
+inline const_registered_buffer buffer(
+    const const_registered_buffer& b) BOOST_ASIO_NOEXCEPT
+{
+  return b;
+}
+
+/// Obtain a buffer representing part of a registered buffer.
+inline mutable_registered_buffer buffer(
+    const mutable_registered_buffer& b, std::size_t n) BOOST_ASIO_NOEXCEPT
+{
+  return mutable_registered_buffer(buffer(b.buffer_, n), b.id_);
+}
+
+/// Obtain a buffer representing part of a registered buffer.
+inline const_registered_buffer buffer(
+    const const_registered_buffer& b, std::size_t n) BOOST_ASIO_NOEXCEPT
+{
+  return const_registered_buffer(buffer(b.buffer_, n), b.id_);
+}
+
+/** @} */
+
+/// Create a new modifiable registered buffer that is offset from the start of
+/// another.
+/**
+ * @relates mutable_registered_buffer
+ */
+inline mutable_registered_buffer operator+(
+    const mutable_registered_buffer& b, std::size_t n) BOOST_ASIO_NOEXCEPT
+{
+  mutable_registered_buffer tmp(b);
+  tmp += n;
+  return tmp;
+}
+
+/// Create a new modifiable buffer that is offset from the start of another.
+/**
+ * @relates mutable_registered_buffer
+ */
+inline mutable_registered_buffer operator+(std::size_t n,
+    const mutable_registered_buffer& b) BOOST_ASIO_NOEXCEPT
+{
+  return b + n;
+}
+
+/// Create a new non-modifiable registered buffer that is offset from the start
+/// of another.
+/**
+ * @relates const_registered_buffer
+ */
+inline const_registered_buffer operator+(const const_registered_buffer& b,
+    std::size_t n) BOOST_ASIO_NOEXCEPT
+{
+  const_registered_buffer tmp(b);
+  tmp += n;
+  return tmp;
+}
+
+/// Create a new non-modifiable buffer that is offset from the start of another.
+/**
+ * @relates const_registered_buffer
+ */
+inline const_registered_buffer operator+(std::size_t n,
+    const const_registered_buffer& b) BOOST_ASIO_NOEXCEPT
+{
+  return b + n;
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_REGISTERED_BUFFER_HPP
diff --git a/boost/asio/require.hpp b/boost/asio/require.hpp
index cbd56026a7f12c7f3d068dbb5591d0e18f32978b..ca9423e3c8dff71168dbcf4f2518b254a541d488 100644
--- a/boost/asio/require.hpp
+++ b/boost/asio/require.hpp
@@ -2,7 +2,7 @@
 // require.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -107,7 +107,7 @@ struct require_result
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_require_fn {
+namespace boost_asio_require_fn {
 
 using boost::asio::conditional;
 using boost::asio::decay;
@@ -406,26 +406,26 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_require_fn
+} // namespace boost_asio_require_fn
 namespace boost {
 namespace asio {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_require_fn::impl&
-  require = asio_require_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_require_fn::impl&
+  require = boost_asio_require_fn::static_instance<>::instance;
 
 } // namespace
 
-typedef asio_require_fn::impl require_t;
+typedef boost_asio_require_fn::impl require_t;
 
 #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename T, typename... Properties>
 struct can_require :
   integral_constant<bool,
-    asio_require_fn::call_traits<
+    boost_asio_require_fn::call_traits<
       require_t, T, void(Properties...)>::overload
-        != asio_require_fn::ill_formed>
+        != boost_asio_require_fn::ill_formed>
 {
 };
 
@@ -435,24 +435,24 @@ template <typename T, typename P0 = void,
     typename P1 = void, typename P2 = void>
 struct can_require :
   integral_constant<bool,
-    asio_require_fn::call_traits<require_t, T, void(P0, P1, P2)>::overload
-      != asio_require_fn::ill_formed>
+    boost_asio_require_fn::call_traits<require_t, T, void(P0, P1, P2)>::overload
+      != boost_asio_require_fn::ill_formed>
 {
 };
 
 template <typename T, typename P0, typename P1>
 struct can_require<T, P0, P1> :
   integral_constant<bool,
-    asio_require_fn::call_traits<require_t, T, void(P0, P1)>::overload
-      != asio_require_fn::ill_formed>
+    boost_asio_require_fn::call_traits<require_t, T, void(P0, P1)>::overload
+      != boost_asio_require_fn::ill_formed>
 {
 };
 
 template <typename T, typename P0>
 struct can_require<T, P0> :
   integral_constant<bool,
-    asio_require_fn::call_traits<require_t, T, void(P0)>::overload
-      != asio_require_fn::ill_formed>
+    boost_asio_require_fn::call_traits<require_t, T, void(P0)>::overload
+      != boost_asio_require_fn::ill_formed>
 {
 };
 
@@ -477,7 +477,7 @@ constexpr bool can_require_v
 template <typename T, typename... Properties>
 struct is_nothrow_require :
   integral_constant<bool,
-    asio_require_fn::call_traits<
+    boost_asio_require_fn::call_traits<
       require_t, T, void(Properties...)>::is_noexcept>
 {
 };
@@ -488,7 +488,7 @@ template <typename T, typename P0 = void,
     typename P1 = void, typename P2 = void>
 struct is_nothrow_require :
   integral_constant<bool,
-    asio_require_fn::call_traits<
+    boost_asio_require_fn::call_traits<
       require_t, T, void(P0, P1, P2)>::is_noexcept>
 {
 };
@@ -496,7 +496,7 @@ struct is_nothrow_require :
 template <typename T, typename P0, typename P1>
 struct is_nothrow_require<T, P0, P1> :
   integral_constant<bool,
-    asio_require_fn::call_traits<
+    boost_asio_require_fn::call_traits<
       require_t, T, void(P0, P1)>::is_noexcept>
 {
 };
@@ -504,7 +504,7 @@ struct is_nothrow_require<T, P0, P1> :
 template <typename T, typename P0>
 struct is_nothrow_require<T, P0> :
   integral_constant<bool,
-    asio_require_fn::call_traits<
+    boost_asio_require_fn::call_traits<
       require_t, T, void(P0)>::is_noexcept>
 {
 };
@@ -530,7 +530,7 @@ constexpr bool is_nothrow_require_v
 template <typename T, typename... Properties>
 struct require_result
 {
-  typedef typename asio_require_fn::call_traits<
+  typedef typename boost_asio_require_fn::call_traits<
       require_t, T, void(Properties...)>::result_type type;
 };
 
@@ -540,21 +540,21 @@ template <typename T, typename P0 = void,
     typename P1 = void, typename P2 = void>
 struct require_result
 {
-  typedef typename asio_require_fn::call_traits<
+  typedef typename boost_asio_require_fn::call_traits<
       require_t, T, void(P0, P1, P2)>::result_type type;
 };
 
 template <typename T, typename P0, typename P1>
 struct require_result<T, P0, P1>
 {
-  typedef typename asio_require_fn::call_traits<
+  typedef typename boost_asio_require_fn::call_traits<
       require_t, T, void(P0, P1)>::result_type type;
 };
 
 template <typename T, typename P0>
 struct require_result<T, P0>
 {
-  typedef typename asio_require_fn::call_traits<
+  typedef typename boost_asio_require_fn::call_traits<
       require_t, T, void(P0)>::result_type type;
 };
 
diff --git a/boost/asio/require_concept.hpp b/boost/asio/require_concept.hpp
index 7fe2b8b4dd5d0d1e679735f39ab248751ffd286e..4bdf91badc0b952ddb75eaf714e8f9cc7bfe7cd8 100644
--- a/boost/asio/require_concept.hpp
+++ b/boost/asio/require_concept.hpp
@@ -2,7 +2,7 @@
 // require_concept.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -107,7 +107,7 @@ struct require_concept_result
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_require_concept_fn {
+namespace boost_asio_require_concept_fn {
 
 using boost::asio::conditional;
 using boost::asio::decay;
@@ -294,24 +294,24 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_require_concept_fn
+} // namespace boost_asio_require_concept_fn
 namespace boost {
 namespace asio {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_require_concept_fn::impl&
-  require_concept = asio_require_concept_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_require_concept_fn::impl&
+  require_concept = boost_asio_require_concept_fn::static_instance<>::instance;
 
 } // namespace
 
-typedef asio_require_concept_fn::impl require_concept_t;
+typedef boost_asio_require_concept_fn::impl require_concept_t;
 
 template <typename T, typename Property>
 struct can_require_concept :
   integral_constant<bool,
-    asio_require_concept_fn::call_traits<
+    boost_asio_require_concept_fn::call_traits<
       require_concept_t, T, void(Property)>::overload !=
-        asio_require_concept_fn::ill_formed>
+        boost_asio_require_concept_fn::ill_formed>
 {
 };
 
@@ -326,7 +326,7 @@ constexpr bool can_require_concept_v
 template <typename T, typename Property>
 struct is_nothrow_require_concept :
   integral_constant<bool,
-    asio_require_concept_fn::call_traits<
+    boost_asio_require_concept_fn::call_traits<
       require_concept_t, T, void(Property)>::is_noexcept>
 {
 };
@@ -342,7 +342,7 @@ constexpr bool is_nothrow_require_concept_v
 template <typename T, typename Property>
 struct require_concept_result
 {
-  typedef typename asio_require_concept_fn::call_traits<
+  typedef typename boost_asio_require_concept_fn::call_traits<
       require_concept_t, T, void(Property)>::result_type type;
 };
 
diff --git a/boost/asio/serial_port.hpp b/boost/asio/serial_port.hpp
index a212c383fe9a5eaf806ec48578de31e3a4b01798..cd405ed70cebc70d967f1c5d7f28d4f7101cd24d 100644
--- a/boost/asio/serial_port.hpp
+++ b/boost/asio/serial_port.hpp
@@ -2,7 +2,7 @@
 // serial_port.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/serial_port_base.hpp b/boost/asio/serial_port_base.hpp
index 4b120403134f4d6990119700cad81201046853ac..84e903d36c046e0507b95b9ec20729fc6980759b 100644
--- a/boost/asio/serial_port_base.hpp
+++ b/boost/asio/serial_port_base.hpp
@@ -2,7 +2,7 @@
 // serial_port_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/signal_set.hpp b/boost/asio/signal_set.hpp
index 5a776851fc69f914cffd32545604dc4e0c028033..eca29e2bcc91970fb8cab3fea1fb0ed6e13ee363 100644
--- a/boost/asio/signal_set.hpp
+++ b/boost/asio/signal_set.hpp
@@ -2,7 +2,7 @@
 // signal_set.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/socket_base.hpp b/boost/asio/socket_base.hpp
index 0b661f3a7e5768e0110a8bbfe8c42513788d76de..c2a5670bc4f0227125c0c05098af298c6a1e9d21 100644
--- a/boost/asio/socket_base.hpp
+++ b/boost/asio/socket_base.hpp
@@ -2,7 +2,7 @@
 // socket_base.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/spawn.hpp b/boost/asio/spawn.hpp
index 429a15e56dd12ee8abf9e8f9be3c59e9b54e6d92..43ad24a4f396b082a11e5e9438a08c731b576708 100644
--- a/boost/asio/spawn.hpp
+++ b/boost/asio/spawn.hpp
@@ -2,7 +2,7 @@
 // spawn.hpp
 // ~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -31,11 +31,12 @@
 namespace boost {
 namespace asio {
 
-/// Context object the represents the currently executing coroutine.
+/// A completion token that represents the currently executing coroutine.
 /**
- * The basic_yield_context class is used to represent the currently executing
- * stackful coroutine. A basic_yield_context may be passed as a handler to an
- * asynchronous operation. For example:
+ * The basic_yield_context class is a completion token type that is used to
+ * represent the currently executing stackful coroutine. A basic_yield_context
+ * object may be passed as a completion token to an asynchronous operation. For
+ * example:
  *
  * @code template <typename Handler>
  * void my_coroutine(basic_yield_context<Handler> yield)
diff --git a/boost/asio/ssl.hpp b/boost/asio/ssl.hpp
index 6cb6ed5de65d1285a08b65e0cb34233507632aef..2c09154c96669f761416a625197ec7ffcd69d855 100644
--- a/boost/asio/ssl.hpp
+++ b/boost/asio/ssl.hpp
@@ -2,7 +2,7 @@
 // ssl.hpp
 // ~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/context.hpp b/boost/asio/ssl/context.hpp
index 8299a2b99bd0ecc2a63e463fb5cbaa97709242c9..78cadcb727f69ae319ec26066dc070a1e4c4f516 100644
--- a/boost/asio/ssl/context.hpp
+++ b/boost/asio/ssl/context.hpp
@@ -2,7 +2,7 @@
 // ssl/context.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -742,6 +742,9 @@ private:
   // Helper function to make a BIO from a memory buffer.
   BOOST_ASIO_DECL BIO* make_buffer_bio(const const_buffer& b);
 
+  // Translate an SSL error into an error code.
+  BOOST_ASIO_DECL static boost::system::error_code translate_error(long error);
+
   // The underlying native implementation.
   native_handle_type handle_;
 
diff --git a/boost/asio/ssl/context_base.hpp b/boost/asio/ssl/context_base.hpp
index 87c3c625a40cafab28ebf835fac452fdf6a4966e..9d94b5da4cce15323a046ac96f64cce99f5146c1 100644
--- a/boost/asio/ssl/context_base.hpp
+++ b/boost/asio/ssl/context_base.hpp
@@ -2,7 +2,7 @@
 // ssl/context_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/detail/buffered_handshake_op.hpp b/boost/asio/ssl/detail/buffered_handshake_op.hpp
index 856cec372499e1b005ce25d39af86115cea6d876..00e999b6b643aad965027f6efbdbdb95d08b800c 100644
--- a/boost/asio/ssl/detail/buffered_handshake_op.hpp
+++ b/boost/asio/ssl/detail/buffered_handshake_op.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/buffered_handshake_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -57,7 +57,7 @@ public:
       const boost::system::error_code& ec,
       const std::size_t& bytes_transferred) const
   {
-    handler(ec, bytes_transferred);
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(ec, bytes_transferred);
   }
 
 private:
diff --git a/boost/asio/ssl/detail/engine.hpp b/boost/asio/ssl/detail/engine.hpp
index f64288fe36aea0116333b7bf6498f1f73ad02752..957d2183656d735650ddcb46c3c954a39974f05d 100644
--- a/boost/asio/ssl/detail/engine.hpp
+++ b/boost/asio/ssl/detail/engine.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/engine.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -59,6 +59,9 @@ public:
   // Construct a new engine for the specified context.
   BOOST_ASIO_DECL explicit engine(SSL_CTX* context);
 
+  // Construct a new engine for an existing native SSL implementation.
+  BOOST_ASIO_DECL explicit engine(SSL* ssl_impl);
+
 #if defined(BOOST_ASIO_HAS_MOVE)
   // Move construct from another engine.
   BOOST_ASIO_DECL engine(engine&& other) BOOST_ASIO_NOEXCEPT;
@@ -67,6 +70,11 @@ public:
   // Destructor.
   BOOST_ASIO_DECL ~engine();
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+  // Move assign from another engine.
+  BOOST_ASIO_DECL engine& operator=(engine&& other) BOOST_ASIO_NOEXCEPT;
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
   // Get the underlying implementation in the native type.
   BOOST_ASIO_DECL SSL* native_handle();
 
diff --git a/boost/asio/ssl/detail/handshake_op.hpp b/boost/asio/ssl/detail/handshake_op.hpp
index 2d683fe29fac1b62e0b4e32b715cfbb78370a862..095137b590980428bae147477181a136307c2edc 100644
--- a/boost/asio/ssl/detail/handshake_op.hpp
+++ b/boost/asio/ssl/detail/handshake_op.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/handshake_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -52,7 +52,7 @@ public:
       const boost::system::error_code& ec,
       const std::size_t&) const
   {
-    handler(ec);
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(ec);
   }
 
 private:
diff --git a/boost/asio/ssl/detail/impl/engine.ipp b/boost/asio/ssl/detail/impl/engine.ipp
index 2def5dd0de1241fe48b3187496645396e0e66fdd..ea373ad86a2fc9c6dad4a7225aaf45c6b05a309a 100644
--- a/boost/asio/ssl/detail/impl/engine.ipp
+++ b/boost/asio/ssl/detail/impl/engine.ipp
@@ -2,7 +2,7 @@
 // ssl/detail/impl/engine.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -56,6 +56,24 @@ engine::engine(SSL_CTX* context)
   ::SSL_set_bio(ssl_, int_bio, int_bio);
 }
 
+engine::engine(SSL* ssl_impl)
+  : ssl_(ssl_impl)
+{
+#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
+  accept_mutex().init();
+#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
+
+  ::SSL_set_mode(ssl_, SSL_MODE_ENABLE_PARTIAL_WRITE);
+  ::SSL_set_mode(ssl_, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
+#if defined(SSL_MODE_RELEASE_BUFFERS)
+  ::SSL_set_mode(ssl_, SSL_MODE_RELEASE_BUFFERS);
+#endif // defined(SSL_MODE_RELEASE_BUFFERS)
+
+  ::BIO* int_bio = 0;
+  ::BIO_new_bio_pair(&int_bio, 0, &ext_bio_, 0);
+  ::SSL_set_bio(ssl_, int_bio, int_bio);
+}
+
 #if defined(BOOST_ASIO_HAS_MOVE)
 engine::engine(engine&& other) BOOST_ASIO_NOEXCEPT
   : ssl_(other.ssl_),
@@ -81,6 +99,20 @@ engine::~engine()
     ::SSL_free(ssl_);
 }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+engine& engine::operator=(engine&& other) BOOST_ASIO_NOEXCEPT
+{
+  if (this != &other)
+  {
+    ssl_ = other.ssl_;
+    ext_bio_ = other.ext_bio_;
+    other.ssl_ = 0;
+    other.ext_bio_ = 0;
+  }
+  return *this;
+}
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
 SSL* engine::native_handle()
 {
   return ssl_;
diff --git a/boost/asio/ssl/detail/impl/openssl_init.ipp b/boost/asio/ssl/detail/impl/openssl_init.ipp
index 5da1bca93bb05488f1e357c6ebb581e7595ad83c..3555caaab311188045b34544e25028a824f7222d 100644
--- a/boost/asio/ssl/detail/impl/openssl_init.ipp
+++ b/boost/asio/ssl/detail/impl/openssl_init.ipp
@@ -3,7 +3,7 @@
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
 // Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2005-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/detail/io.hpp b/boost/asio/ssl/detail/io.hpp
index f8d81c1e31085d8bde1a417410b401982dd5394f..fd58635fb4fa0b570b0a21e81a8ce66ef9e17a24 100644
--- a/boost/asio/ssl/detail/io.hpp
+++ b/boost/asio/ssl/detail/io.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/io.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -17,6 +17,7 @@
 
 #include <boost/asio/detail/config.hpp>
 
+#include <boost/asio/detail/base_from_cancellation_state.hpp>
 #include <boost/asio/detail/handler_tracking.hpp>
 #include <boost/asio/ssl/detail/engine.hpp>
 #include <boost/asio/ssl/detail/stream_core.hpp>
@@ -95,11 +96,13 @@ std::size_t io(Stream& next_layer, stream_core& core,
 
 template <typename Stream, typename Operation, typename Handler>
 class io_op
+  : public boost::asio::detail::base_from_cancellation_state<Handler>
 {
 public:
   io_op(Stream& next_layer, stream_core& core,
       const Operation& op, Handler& handler)
-    : next_layer_(next_layer),
+    : boost::asio::detail::base_from_cancellation_state<Handler>(handler),
+      next_layer_(next_layer),
       core_(core),
       op_(op),
       start_(0),
@@ -111,7 +114,8 @@ public:
 
 #if defined(BOOST_ASIO_HAS_MOVE)
   io_op(const io_op& other)
-    : next_layer_(other.next_layer_),
+    : boost::asio::detail::base_from_cancellation_state<Handler>(other),
+      next_layer_(other.next_layer_),
       core_(other.core_),
       op_(other.op_),
       start_(other.start_),
@@ -123,7 +127,11 @@ public:
   }
 
   io_op(io_op&& other)
-    : next_layer_(other.next_layer_),
+    : boost::asio::detail::base_from_cancellation_state<Handler>(
+        BOOST_ASIO_MOVE_CAST(
+          boost::asio::detail::base_from_cancellation_state<Handler>)(
+            other)),
+      next_layer_(other.next_layer_),
       core_(other.core_),
       op_(BOOST_ASIO_MOVE_CAST(Operation)(other.op_)),
       start_(other.start_),
@@ -263,6 +271,13 @@ public:
           // Release any waiting read operations.
           core_.pending_read_.expires_at(core_.neg_infin());
 
+          // Check for cancellation before continuing.
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec_ = boost::asio::error::operation_aborted;
+            break;
+          }
+
           // Try the operation again.
           continue;
 
@@ -271,6 +286,13 @@ public:
           // Release any waiting write operations.
           core_.pending_write_.expires_at(core_.neg_infin());
 
+          // Check for cancellation before continuing.
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec_ = boost::asio::error::operation_aborted;
+            break;
+          }
+
           // Try the operation again.
           continue;
 
@@ -381,32 +403,19 @@ inline void async_io(Stream& next_layer, stream_core& core,
 } // namespace detail
 } // namespace ssl
 
-template <typename Stream, typename Operation,
-    typename Handler, typename Allocator>
-struct associated_allocator<
-    ssl::detail::io_op<Stream, Operation, Handler>, Allocator>
+template <template <typename, typename> class Associator,
+    typename Stream, typename Operation,
+    typename Handler, typename DefaultCandidate>
+struct associator<Associator,
+    ssl::detail::io_op<Stream, Operation, Handler>,
+    DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(const ssl::detail::io_op<Stream, Operation, Handler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename Stream, typename Operation,
-    typename Handler, typename Executor>
-struct associated_executor<
-    ssl::detail::io_op<Stream, Operation, Handler>, Executor>
-  : detail::associated_executor_forwarding_base<Handler, Executor>
-{
-  typedef typename associated_executor<Handler, Executor>::type type;
-
-  static type get(const ssl::detail::io_op<Stream, Operation, Handler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const ssl::detail::io_op<Stream, Operation, Handler>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 
diff --git a/boost/asio/ssl/detail/openssl_init.hpp b/boost/asio/ssl/detail/openssl_init.hpp
index 0155a6f85c298b19875604fbd775f6c1e450db88..be96173bc3719202e5a0f70bf7acbb10e2c2fa29 100644
--- a/boost/asio/ssl/detail/openssl_init.hpp
+++ b/boost/asio/ssl/detail/openssl_init.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/openssl_init.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/detail/openssl_types.hpp b/boost/asio/ssl/detail/openssl_types.hpp
index 3a87a1968cd709aeb15ce71531449d82bda99836..da6cf47e47d30c2901374b2376fbf59ae090d80c 100644
--- a/boost/asio/ssl/detail/openssl_types.hpp
+++ b/boost/asio/ssl/detail/openssl_types.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/openssl_types.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/detail/password_callback.hpp b/boost/asio/ssl/detail/password_callback.hpp
index 74c089e82fe3ce10e0cc157b07bdc6d2011f8746..6751024e963ca40c14740293e61ca76d47095f6d 100644
--- a/boost/asio/ssl/detail/password_callback.hpp
+++ b/boost/asio/ssl/detail/password_callback.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/password_callback.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/detail/read_op.hpp b/boost/asio/ssl/detail/read_op.hpp
index b7eea499552e7ee69dff97b8761ebad2c1aa3eae..a8d500489a18a1d130847d058929982420e2310d 100644
--- a/boost/asio/ssl/detail/read_op.hpp
+++ b/boost/asio/ssl/detail/read_op.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/read_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -57,7 +57,7 @@ public:
       const boost::system::error_code& ec,
       const std::size_t& bytes_transferred) const
   {
-    handler(ec, bytes_transferred);
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(ec, bytes_transferred);
   }
 
 private:
diff --git a/boost/asio/ssl/detail/shutdown_op.hpp b/boost/asio/ssl/detail/shutdown_op.hpp
index c2a33ba846237f1eb1aacf4746fac67df2f041bf..fe6a1ba0cc2d5273353309f5a407f1319291239f 100644
--- a/boost/asio/ssl/detail/shutdown_op.hpp
+++ b/boost/asio/ssl/detail/shutdown_op.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/shutdown_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -52,11 +52,11 @@ public:
       // The engine only generates an eof when the shutdown notification has
       // been received from the peer. This indicates that the shutdown has
       // completed successfully, and thus need not be passed on to the handler.
-      handler(boost::system::error_code());
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(boost::system::error_code());
     }
     else
     {
-      handler(ec);
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(ec);
     }
   }
 };
diff --git a/boost/asio/ssl/detail/stream_core.hpp b/boost/asio/ssl/detail/stream_core.hpp
index bdeaf514f971dc793f72cd0f0010a46adaca954b..d3ba395e687daaafd63e3cb1bcdf12b2590a6704 100644
--- a/boost/asio/ssl/detail/stream_core.hpp
+++ b/boost/asio/ssl/detail/stream_core.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/stream_core.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -52,6 +52,20 @@ struct stream_core
     pending_write_.expires_at(neg_infin());
   }
 
+  template <typename Executor>
+  stream_core(SSL* ssl_impl, const Executor& ex)
+    : engine_(ssl_impl),
+      pending_read_(ex),
+      pending_write_(ex),
+      output_buffer_space_(max_tls_record_size),
+      output_buffer_(boost::asio::buffer(output_buffer_space_)),
+      input_buffer_space_(max_tls_record_size),
+      input_buffer_(boost::asio::buffer(input_buffer_space_))
+  {
+    pending_read_.expires_at(neg_infin());
+    pending_write_.expires_at(neg_infin());
+  }
+
 #if defined(BOOST_ASIO_HAS_MOVE)
   stream_core(stream_core&& other)
     : engine_(BOOST_ASIO_MOVE_CAST(engine)(other.engine_)),
@@ -90,6 +104,44 @@ struct stream_core
   {
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+  stream_core& operator=(stream_core&& other)
+  {
+    if (this != &other)
+    {
+      engine_ = BOOST_ASIO_MOVE_CAST(engine)(other.engine_);
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+      pending_read_ =
+        BOOST_ASIO_MOVE_CAST(boost::asio::deadline_timer)(
+          other.pending_read_);
+      pending_write_ =
+        BOOST_ASIO_MOVE_CAST(boost::asio::deadline_timer)(
+          other.pending_write_);
+#else // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+      pending_read_ =
+        BOOST_ASIO_MOVE_CAST(boost::asio::steady_timer)(
+          other.pending_read_);
+      pending_write_ =
+        BOOST_ASIO_MOVE_CAST(boost::asio::steady_timer)(
+          other.pending_write_);
+#endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+      output_buffer_space_ =
+        BOOST_ASIO_MOVE_CAST(std::vector<unsigned char>)(
+          other.output_buffer_space_);
+      output_buffer_ = other.output_buffer_;
+      input_buffer_space_ =
+        BOOST_ASIO_MOVE_CAST(std::vector<unsigned char>)(
+          other.input_buffer_space_);
+      input_buffer_ = other.input_buffer_;
+      input_ = other.input_;
+      other.output_buffer_ = boost::asio::mutable_buffer(0, 0);
+      other.input_buffer_ = boost::asio::mutable_buffer(0, 0);
+      other.input_ = boost::asio::const_buffer(0, 0);
+    }
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
   // The SSL engine.
   engine engine_;
 
diff --git a/boost/asio/ssl/detail/verify_callback.hpp b/boost/asio/ssl/detail/verify_callback.hpp
index ffd0ced806a0828cc9480f67cfd35589bd989d87..b61551b1e969fb7c212f906812caaa94e8a84e7c 100644
--- a/boost/asio/ssl/detail/verify_callback.hpp
+++ b/boost/asio/ssl/detail/verify_callback.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/verify_callback.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/detail/write_op.hpp b/boost/asio/ssl/detail/write_op.hpp
index b19aee6f8544fb021be405e3f5e8c6f66952fc0a..e8fa3c8ec767c4d5ee3c8f7ae5d115e70f3df367 100644
--- a/boost/asio/ssl/detail/write_op.hpp
+++ b/boost/asio/ssl/detail/write_op.hpp
@@ -2,7 +2,7 @@
 // ssl/detail/write_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -61,7 +61,7 @@ public:
       const boost::system::error_code& ec,
       const std::size_t& bytes_transferred) const
   {
-    handler(ec, bytes_transferred);
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(ec, bytes_transferred);
   }
 
 private:
diff --git a/boost/asio/ssl/error.hpp b/boost/asio/ssl/error.hpp
index efa21e533907f94bb840870ade23a80c60ab88f7..7e8f897799bb9cc43fac7cbc6e39a507a748db48 100644
--- a/boost/asio/ssl/error.hpp
+++ b/boost/asio/ssl/error.hpp
@@ -2,7 +2,7 @@
 // ssl/error.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/host_name_verification.hpp b/boost/asio/ssl/host_name_verification.hpp
index 187b1ae643feb5a71ba85e277b67ac953d131323..669b19a82c410bf91733e118882eec8056c1a3e2 100644
--- a/boost/asio/ssl/host_name_verification.hpp
+++ b/boost/asio/ssl/host_name_verification.hpp
@@ -2,7 +2,7 @@
 // ssl/host_name_verification.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/impl/context.hpp b/boost/asio/ssl/impl/context.hpp
index 300c5b2f56dcc41153b6549039fb6ded95bfcc30..6f70b1509927d99dd8dddb66861b75d289eb781c 100644
--- a/boost/asio/ssl/impl/context.hpp
+++ b/boost/asio/ssl/impl/context.hpp
@@ -3,7 +3,7 @@
 // ~~~~~~~~~~~~~~~~~~~~
 //
 // Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2005-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/impl/context.ipp b/boost/asio/ssl/impl/context.ipp
index ec0ec8b98458aa9b21aca8cfeb32d734b026bef1..e3985c14390eaaf155b047b3e39a7f9fcb9de9df 100644
--- a/boost/asio/ssl/impl/context.ipp
+++ b/boost/asio/ssl/impl/context.ipp
@@ -3,7 +3,7 @@
 // ~~~~~~~~~~~~~~~~~~~~
 //
 // Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2005-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -48,6 +48,7 @@ struct context::evp_pkey_cleanup
   ~evp_pkey_cleanup() { if (p) ::EVP_PKEY_free(p); }
 };
 
+#if (OPENSSL_VERSION_NUMBER < 0x30000000L)
 struct context::rsa_cleanup
 {
   RSA* p;
@@ -59,6 +60,7 @@ struct context::dh_cleanup
   DH* p;
   ~dh_cleanup() { if (p) ::DH_free(p); }
 };
+#endif // (OPENSSL_VERSION_NUMBER < 0x30000000L)
 
 context::context(context::method m)
   : handle_(0)
@@ -358,9 +360,7 @@ context::context(context::method m)
 
   if (handle_ == 0)
   {
-    boost::system::error_code ec(
-        static_cast<int>(::ERR_get_error()),
-        boost::asio::error::get_ssl_category());
+    boost::system::error_code ec = translate_error(::ERR_get_error());
     boost::asio::detail::throw_error(ec, "context");
   }
 
@@ -398,7 +398,8 @@ context::~context()
   if (handle_)
   {
 #if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
     void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
 #else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
@@ -411,7 +412,8 @@ context::~context()
             cb_userdata);
       delete callback;
 #if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
       ::SSL_CTX_set_default_passwd_cb_userdata(handle_, 0);
 #else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
@@ -544,9 +546,7 @@ BOOST_ASIO_SYNC_OP_VOID context::load_verify_file(
 
   if (::SSL_CTX_load_verify_locations(handle_, filename.c_str(), 0) != 1)
   {
-    ec = boost::system::error_code(
-        static_cast<int>(::ERR_get_error()),
-        boost::asio::error::get_ssl_category());
+    ec = translate_error(::ERR_get_error());
     BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
@@ -581,17 +581,13 @@ BOOST_ASIO_SYNC_OP_VOID context::add_certificate_authority(
               && ERR_GET_REASON(err) == PEM_R_NO_START_LINE)
             break;
 
-          ec = boost::system::error_code(
-              static_cast<int>(err),
-              boost::asio::error::get_ssl_category());
+          ec = translate_error(err);
           BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
         }
 
         if (::X509_STORE_add_cert(store, cert.p) != 1)
         {
-          ec = boost::system::error_code(
-              static_cast<int>(::ERR_get_error()),
-              boost::asio::error::get_ssl_category());
+          ec = translate_error(::ERR_get_error());
           BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
         }
       }
@@ -616,9 +612,7 @@ BOOST_ASIO_SYNC_OP_VOID context::set_default_verify_paths(
 
   if (::SSL_CTX_set_default_verify_paths(handle_) != 1)
   {
-    ec = boost::system::error_code(
-        static_cast<int>(::ERR_get_error()),
-        boost::asio::error::get_ssl_category());
+    ec = translate_error(::ERR_get_error());
     BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
@@ -640,9 +634,7 @@ BOOST_ASIO_SYNC_OP_VOID context::add_verify_path(
 
   if (::SSL_CTX_load_verify_locations(handle_, 0, path.c_str()) != 1)
   {
-    ec = boost::system::error_code(
-        static_cast<int>(::ERR_get_error()),
-        boost::asio::error::get_ssl_category());
+    ec = translate_error(::ERR_get_error());
     BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
@@ -696,9 +688,7 @@ BOOST_ASIO_SYNC_OP_VOID context::use_certificate(
     BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
-  ec = boost::system::error_code(
-      static_cast<int>(::ERR_get_error()),
-      boost::asio::error::get_ssl_category());
+  ec = translate_error(::ERR_get_error());
   BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
@@ -734,9 +724,7 @@ BOOST_ASIO_SYNC_OP_VOID context::use_certificate_file(
 
   if (::SSL_CTX_use_certificate_file(handle_, filename.c_str(), file_type) != 1)
   {
-    ec = boost::system::error_code(
-        static_cast<int>(::ERR_get_error()),
-        boost::asio::error::get_ssl_category());
+    ec = translate_error(::ERR_get_error());
     BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
@@ -760,7 +748,8 @@ BOOST_ASIO_SYNC_OP_VOID context::use_certificate_chain(
   if (bio.p)
   {
 #if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
     pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
     void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
@@ -774,22 +763,20 @@ BOOST_ASIO_SYNC_OP_VOID context::use_certificate_chain(
           cb_userdata) };
     if (!cert.p)
     {
-      ec = boost::system::error_code(ERR_R_PEM_LIB,
-          boost::asio::error::get_ssl_category());
+      ec = translate_error(ERR_R_PEM_LIB);
       BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
     }
 
     int result = ::SSL_CTX_use_certificate(handle_, cert.p);
     if (result == 0 || ::ERR_peek_error() != 0)
     {
-      ec = boost::system::error_code(
-          static_cast<int>(::ERR_get_error()),
-          boost::asio::error::get_ssl_category());
+      ec = translate_error(::ERR_get_error());
       BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
     }
 
 #if ((OPENSSL_VERSION_NUMBER >= 0x10002000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2090100fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
     ::SSL_CTX_clear_chain_certs(handle_);
 #else
@@ -806,9 +793,7 @@ BOOST_ASIO_SYNC_OP_VOID context::use_certificate_chain(
     {
       if (!::SSL_CTX_add_extra_chain_cert(handle_, cacert))
       {
-        ec = boost::system::error_code(
-            static_cast<int>(::ERR_get_error()),
-            boost::asio::error::get_ssl_category());
+        ec = translate_error(::ERR_get_error());
         BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
       }
     }
@@ -823,9 +808,7 @@ BOOST_ASIO_SYNC_OP_VOID context::use_certificate_chain(
     }
   }
 
-  ec = boost::system::error_code(
-      static_cast<int>(::ERR_get_error()),
-      boost::asio::error::get_ssl_category());
+  ec = translate_error(::ERR_get_error());
   BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
@@ -843,9 +826,7 @@ BOOST_ASIO_SYNC_OP_VOID context::use_certificate_chain_file(
 
   if (::SSL_CTX_use_certificate_chain_file(handle_, filename.c_str()) != 1)
   {
-    ec = boost::system::error_code(
-        static_cast<int>(::ERR_get_error()),
-        boost::asio::error::get_ssl_category());
+    ec = translate_error(::ERR_get_error());
     BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
@@ -868,7 +849,8 @@ BOOST_ASIO_SYNC_OP_VOID context::use_private_key(
   ::ERR_clear_error();
 
 #if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
     pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
     void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
@@ -908,9 +890,7 @@ BOOST_ASIO_SYNC_OP_VOID context::use_private_key(
     }
   }
 
-  ec = boost::system::error_code(
-      static_cast<int>(::ERR_get_error()),
-      boost::asio::error::get_ssl_category());
+  ec = translate_error(::ERR_get_error());
   BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
@@ -937,18 +917,54 @@ BOOST_ASIO_SYNC_OP_VOID context::use_rsa_private_key(
   ::ERR_clear_error();
 
 #if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
-    pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
-    void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
+  pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
+  void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
 #else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-    pem_password_cb* callback = handle_->default_passwd_callback;
-    void* cb_userdata = handle_->default_passwd_callback_userdata;
+  pem_password_cb* callback = handle_->default_passwd_callback;
+  void* cb_userdata = handle_->default_passwd_callback_userdata;
 #endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
 
   bio_cleanup bio = { make_buffer_bio(private_key) };
   if (bio.p)
   {
+#if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
+    evp_pkey_cleanup evp_private_key = { 0 };
+    switch (format)
+    {
+    case context_base::asn1:
+      evp_private_key.p = ::d2i_PrivateKey_bio(bio.p, 0);
+      break;
+    case context_base::pem:
+      evp_private_key.p = ::PEM_read_bio_PrivateKey(
+          bio.p, 0, callback,
+          cb_userdata);
+      break;
+    default:
+      {
+        ec = boost::asio::error::invalid_argument;
+        BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+      }
+    }
+
+    if (evp_private_key.p)
+    {
+      if (::EVP_PKEY_is_a(evp_private_key.p, "RSA") == 0)
+      {
+        ec = translate_error(
+            ERR_PACK(ERR_LIB_EVP, 0, EVP_R_EXPECTING_AN_RSA_KEY));
+        BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+      }
+
+      if (::SSL_CTX_use_PrivateKey(handle_, evp_private_key.p) == 1)
+      {
+        ec = boost::system::error_code();
+        BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+      }
+    }
+#else // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
     rsa_cleanup rsa_private_key = { 0 };
     switch (format)
     {
@@ -975,11 +991,10 @@ BOOST_ASIO_SYNC_OP_VOID context::use_rsa_private_key(
         BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
       }
     }
+#endif // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
   }
 
-  ec = boost::system::error_code(
-      static_cast<int>(::ERR_get_error()),
-      boost::asio::error::get_ssl_category());
+  ec = translate_error(::ERR_get_error());
   BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
@@ -1007,9 +1022,7 @@ BOOST_ASIO_SYNC_OP_VOID context::use_private_key_file(
 
   if (::SSL_CTX_use_PrivateKey_file(handle_, filename.c_str(), file_type) != 1)
   {
-    ec = boost::system::error_code(
-        static_cast<int>(::ERR_get_error()),
-        boost::asio::error::get_ssl_category());
+    ec = translate_error(::ERR_get_error());
     BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
@@ -1029,6 +1042,53 @@ BOOST_ASIO_SYNC_OP_VOID context::use_rsa_private_key_file(
     const std::string& filename, context::file_format format,
     boost::system::error_code& ec)
 {
+#if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
+  ::ERR_clear_error();
+
+  pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
+  void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
+
+  bio_cleanup bio = { ::BIO_new_file(filename.c_str(), "r") };
+  if (bio.p)
+  {
+    evp_pkey_cleanup evp_private_key = { 0 };
+    switch (format)
+    {
+    case context_base::asn1:
+      evp_private_key.p = ::d2i_PrivateKey_bio(bio.p, 0);
+      break;
+    case context_base::pem:
+      evp_private_key.p = ::PEM_read_bio_PrivateKey(
+          bio.p, 0, callback,
+          cb_userdata);
+      break;
+    default:
+      {
+        ec = boost::asio::error::invalid_argument;
+        BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+      }
+    }
+
+    if (evp_private_key.p)
+    {
+      if (::EVP_PKEY_is_a(evp_private_key.p, "RSA") == 0)
+      {
+        ec = translate_error(
+            ERR_PACK(ERR_LIB_EVP, 0, EVP_R_EXPECTING_AN_RSA_KEY));
+        BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+      }
+
+      if (::SSL_CTX_use_PrivateKey(handle_, evp_private_key.p) == 1)
+      {
+        ec = boost::system::error_code();
+        BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+      }
+    }
+  }
+
+  ec = translate_error(::ERR_get_error());
+  BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+#else // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
   int file_type;
   switch (format)
   {
@@ -1050,14 +1110,13 @@ BOOST_ASIO_SYNC_OP_VOID context::use_rsa_private_key_file(
   if (::SSL_CTX_use_RSAPrivateKey_file(
         handle_, filename.c_str(), file_type) != 1)
   {
-    ec = boost::system::error_code(
-        static_cast<int>(::ERR_get_error()),
-        boost::asio::error::get_ssl_category());
+    ec = translate_error(::ERR_get_error());
     BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   ec = boost::system::error_code();
   BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+#endif // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
 }
 
 void context::use_tmp_dh(const const_buffer& dh)
@@ -1078,9 +1137,7 @@ BOOST_ASIO_SYNC_OP_VOID context::use_tmp_dh(
     return do_use_tmp_dh(bio.p, ec);
   }
 
-  ec = boost::system::error_code(
-      static_cast<int>(::ERR_get_error()),
-      boost::asio::error::get_ssl_category());
+  ec = translate_error(::ERR_get_error());
   BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
@@ -1102,9 +1159,7 @@ BOOST_ASIO_SYNC_OP_VOID context::use_tmp_dh_file(
     return do_use_tmp_dh(bio.p, ec);
   }
 
-  ec = boost::system::error_code(
-      static_cast<int>(::ERR_get_error()),
-      boost::asio::error::get_ssl_category());
+  ec = translate_error(::ERR_get_error());
   BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
@@ -1113,6 +1168,19 @@ BOOST_ASIO_SYNC_OP_VOID context::do_use_tmp_dh(
 {
   ::ERR_clear_error();
 
+#if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
+  EVP_PKEY* p = ::PEM_read_bio_Parameters(bio, 0);
+  if (p)
+  {
+    if (::SSL_CTX_set0_tmp_dh_pkey(handle_, p) == 1)
+    {
+      ec = boost::system::error_code();
+      BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+    }
+    else
+      ::EVP_PKEY_free(p);
+  }
+#else // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
   dh_cleanup dh = { ::PEM_read_bio_DHparams(bio, 0, 0, 0) };
   if (dh.p)
   {
@@ -1122,10 +1190,9 @@ BOOST_ASIO_SYNC_OP_VOID context::do_use_tmp_dh(
       BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
     }
   }
+#endif // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
 
-  ec = boost::system::error_code(
-      static_cast<int>(::ERR_get_error()),
-      boost::asio::error::get_ssl_category());
+  ec = translate_error(::ERR_get_error());
   BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
 }
 
@@ -1178,7 +1245,8 @@ BOOST_ASIO_SYNC_OP_VOID context::do_set_password_callback(
     detail::password_callback_base* callback, boost::system::error_code& ec)
 {
 #if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
   void* old_callback = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
   ::SSL_CTX_set_default_passwd_cb_userdata(handle_, callback);
@@ -1231,6 +1299,21 @@ BIO* context::make_buffer_bio(const const_buffer& b)
       static_cast<int>(b.size()));
 }
 
+boost::system::error_code context::translate_error(long error)
+{
+#if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
+  if (ERR_SYSTEM_ERROR(error))
+  {
+    return boost::system::error_code(
+        static_cast<int>(ERR_GET_REASON(error)),
+        boost::asio::error::get_system_category());
+  }
+#endif // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
+
+  return boost::system::error_code(static_cast<int>(error),
+      boost::asio::error::get_ssl_category());
+}
+
 } // namespace ssl
 } // namespace asio
 } // namespace boost
diff --git a/boost/asio/ssl/impl/error.ipp b/boost/asio/ssl/impl/error.ipp
index 57f149fc9e23ea1b85133161a75cfb57ab73f232..b33be6367327487801207f8d77abb41e4d8120dc 100644
--- a/boost/asio/ssl/impl/error.ipp
+++ b/boost/asio/ssl/impl/error.ipp
@@ -2,7 +2,7 @@
 // ssl/impl/error.ipp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -36,8 +36,30 @@ public:
 
   std::string message(int value) const
   {
-    const char* s = ::ERR_reason_error_string(value);
-    return s ? s : "asio.ssl error";
+    const char* reason = ::ERR_reason_error_string(value);
+    if (reason)
+    {
+      const char* lib = ::ERR_lib_error_string(value);
+#if (OPENSSL_VERSION_NUMBER < 0x30000000L)
+      const char* func = ::ERR_func_error_string(value);
+#else // (OPENSSL_VERSION_NUMBER < 0x30000000L)
+      const char* func = 0;
+#endif // (OPENSSL_VERSION_NUMBER < 0x30000000L)
+      std::string result(reason);
+      if (lib || func)
+      {
+        result += " (";
+        if (lib)
+          result += lib;
+        if (lib && func)
+          result += ", ";
+        if (func)
+          result += func;
+        result += ")";
+      }
+      return result;
+    }
+    return "asio.ssl error";
   }
 };
 
diff --git a/boost/asio/ssl/impl/host_name_verification.ipp b/boost/asio/ssl/impl/host_name_verification.ipp
index b0675dbeb04f6f3f229244116938aae148da9708..5b50c670df5151a87cd9aad5811aa04fd27c14ff 100644
--- a/boost/asio/ssl/impl/host_name_verification.ipp
+++ b/boost/asio/ssl/impl/host_name_verification.ipp
@@ -2,7 +2,7 @@
 // ssl/impl/host_name_verification.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/impl/rfc2818_verification.ipp b/boost/asio/ssl/impl/rfc2818_verification.ipp
index 38b422fe41b5afc51f04a423e57b2b298d4eaf63..a07c729a50b1fd03a98a34ab0ab1335a0580903b 100644
--- a/boost/asio/ssl/impl/rfc2818_verification.ipp
+++ b/boost/asio/ssl/impl/rfc2818_verification.ipp
@@ -2,7 +2,7 @@
 // ssl/impl/rfc2818_verification.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/impl/src.hpp b/boost/asio/ssl/impl/src.hpp
index 8d38d13e2a76505cd765a98d50e4002a76c479aa..91520d62d3f6160710e58cac35803da9be54d758 100644
--- a/boost/asio/ssl/impl/src.hpp
+++ b/boost/asio/ssl/impl/src.hpp
@@ -2,7 +2,7 @@
 // impl/ssl/src.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/rfc2818_verification.hpp b/boost/asio/ssl/rfc2818_verification.hpp
index 39eddbbecc67207c68484e6be465ab4cea088129..38518b86da1483a5d549d3f310109a8a50db04c9 100644
--- a/boost/asio/ssl/rfc2818_verification.hpp
+++ b/boost/asio/ssl/rfc2818_verification.hpp
@@ -2,7 +2,7 @@
 // ssl/rfc2818_verification.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/stream.hpp b/boost/asio/ssl/stream.hpp
index 0a7c805d3cca839101ac7e5aa76aaa3810327a30..b82da1cd032dc5d80ad1dfe437ed76a356ed47a4 100644
--- a/boost/asio/ssl/stream.hpp
+++ b/boost/asio/ssl/stream.hpp
@@ -2,7 +2,7 @@
 // ssl/stream.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -101,6 +101,23 @@ public:
       core_(ctx.native_handle(), next_layer_.lowest_layer().get_executor())
   {
   }
+
+  /// Construct a stream from an existing native implementation.
+  /**
+   * This constructor creates a stream and initialises the underlying stream
+   * object. On success, ownership of the native implementation is transferred
+   * to the stream, and it will be cleaned up when the stream is destroyed.
+   *
+   * @param arg The argument to be passed to initialise the underlying stream.
+   *
+   * @param handle An existing native SSL implementation.
+   */
+  template <typename Arg>
+  stream(Arg&& arg, native_handle_type handle)
+    : next_layer_(BOOST_ASIO_MOVE_CAST(Arg)(arg)),
+      core_(handle, next_layer_.lowest_layer().get_executor())
+  {
+  }
 #else // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
   template <typename Arg>
   stream(Arg& arg, context& ctx)
@@ -108,6 +125,13 @@ public:
       core_(ctx.native_handle(), next_layer_.lowest_layer().get_executor())
   {
   }
+
+  template <typename Arg>
+  stream(Arg& arg, native_handle_type handle)
+    : next_layer_(arg),
+      core_(handle, next_layer_.lowest_layer().get_executor())
+  {
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
 #if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
@@ -116,13 +140,30 @@ public:
    * @param other The other stream object from which the move will occur. Must
    * have no outstanding asynchronous operations associated with it. Following
    * the move, @c other has a valid but unspecified state where the only safe
-   * operation is destruction.
+   * operation is destruction, or use as the target of a move assignment.
    */
   stream(stream&& other)
     : next_layer_(BOOST_ASIO_MOVE_CAST(Stream)(other.next_layer_)),
       core_(BOOST_ASIO_MOVE_CAST(detail::stream_core)(other.core_))
   {
   }
+
+  /// Move-assign a stream from another.
+  /**
+   * @param other The other stream object from which the move will occur. Must
+   * have no outstanding asynchronous operations associated with it. Following
+   * the move, @c other has a valid but unspecified state where the only safe
+   * operation is destruction, or use as the target of a move assignment.
+   */
+  stream& operator=(stream&& other)
+  {
+    if (this != &other)
+    {
+      next_layer_ = BOOST_ASIO_MOVE_CAST(Stream)(other.next_layer_);
+      core_ = BOOST_ASIO_MOVE_CAST(detail::stream_core)(other.core_);
+    }
+    return *this;
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destructor.
@@ -434,37 +475,59 @@ public:
   /// Start an asynchronous SSL handshake.
   /**
    * This function is used to asynchronously perform an SSL handshake on the
-   * stream. This function call always returns immediately.
+   * stream. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param type The type of handshaking to be performed, i.e. as a client or as
    * a server.
    *
-   * @param handler The handler to be called when the handshake operation
-   * completes. Copies will be made of the handler as required. The equivalent
-   * function signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the handshake completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * if they are also supported by the @c Stream type's @c async_read_some and
+   * @c async_write_some operations.
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
-        HandshakeHandler
+        HandshakeToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(HandshakeHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(HandshakeToken,
       void (boost::system::error_code))
   async_handshake(handshake_type type,
-      BOOST_ASIO_MOVE_ARG(HandshakeHandler) handler
+      BOOST_ASIO_MOVE_ARG(HandshakeToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<HandshakeHandler,
+    return async_initiate<HandshakeToken,
       void (boost::system::error_code)>(
-        initiate_async_handshake(this), handler, type);
+        initiate_async_handshake(this), token, type);
   }
 
   /// Start an asynchronous SSL handshake.
   /**
    * This function is used to asynchronously perform an SSL handshake on the
-   * stream. This function call always returns immediately.
+   * stream. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param type The type of handshaking to be performed, i.e. as a client or as
    * a server.
@@ -472,29 +535,49 @@ public:
    * @param buffers The buffered data to be reused for the handshake. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * buffers is retained by the caller, which must guarantee that they remain
-   * valid until the handler is called.
+   * valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the handshake operation
-   * completes. Copies will be made of the handler as required. The equivalent
-   * function signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the handshake completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred // Amount of buffers used in handshake.
    * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * if they are also supported by the @c Stream type's @c async_read_some and
+   * @c async_write_some operations.
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) BufferedHandshakeHandler
+        std::size_t)) BufferedHandshakeToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(BufferedHandshakeHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(BufferedHandshakeToken,
       void (boost::system::error_code, std::size_t))
   async_handshake(handshake_type type, const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(BufferedHandshakeHandler) handler
+      BOOST_ASIO_MOVE_ARG(BufferedHandshakeToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<BufferedHandshakeHandler,
+    return async_initiate<BufferedHandshakeToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_buffered_handshake(this), handler, type, buffers);
+        initiate_async_buffered_handshake(this), token, type, buffers);
   }
 
   /// Shut down SSL on the stream.
@@ -526,29 +609,50 @@ public:
 
   /// Asynchronously shut down SSL on the stream.
   /**
-   * This function is used to asynchronously shut down SSL on the stream. This
-   * function call always returns immediately.
-   *
-   * @param handler The handler to be called when the handshake operation
-   * completes. Copies will be made of the handler as required. The equivalent
-   * function signature of the handler must be:
+   * This function is used to asynchronously shut down SSL on the stream. It is
+   * an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
+   *
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the shutdown completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * if they are also supported by the @c Stream type's @c async_read_some and
+   * @c async_write_some operations.
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
-        ShutdownHandler
+        ShutdownToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ShutdownHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ShutdownToken,
       void (boost::system::error_code))
   async_shutdown(
-      BOOST_ASIO_MOVE_ARG(ShutdownHandler) handler
+      BOOST_ASIO_MOVE_ARG(ShutdownToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ShutdownHandler,
+    return async_initiate<ShutdownToken,
       void (boost::system::error_code)>(
-        initiate_async_shutdown(this), handler);
+        initiate_async_shutdown(this), token);
   }
 
   /// Write some data to the stream.
@@ -603,39 +707,60 @@ public:
   /// Start an asynchronous write.
   /**
    * This function is used to asynchronously write one or more bytes of data to
-   * the stream. The function call always returns immediately.
+   * the stream. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers The data to be written to the stream. Although the buffers
    * object may be copied as necessary, ownership of the underlying buffers is
    * retained by the caller, which must guarantee that they remain valid until
-   * the handler is called.
+   * the completion handler is called.
    *
-   * @param handler The handler to be called when the write operation completes.
-   * Copies will be made of the handler as required. The equivalent function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes written.
+   *   std::size_t bytes_transferred // Number of bytes written.
    * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
    *
    * @note The async_write_some operation may not transmit all of the data to
    * the peer. Consider using the @ref async_write function if you need to
    * ensure that all data is written before the asynchronous operation
    * completes.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * if they are also supported by the @c Stream type's @c async_read_some and
+   * @c async_write_some operations.
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_write_some(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_write_some(this), handler, buffers);
+        initiate_async_write_some(this), token, buffers);
   }
 
   /// Read some data from the stream.
@@ -690,39 +815,60 @@ public:
   /// Start an asynchronous read.
   /**
    * This function is used to asynchronously read one or more bytes of data from
-   * the stream. The function call always returns immediately.
+   * the stream. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
    * @param buffers The buffers into which the data will be read. Although the
    * buffers object may be copied as necessary, ownership of the underlying
    * buffers is retained by the caller, which must guarantee that they remain
-   * valid until the handler is called.
+   * valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the read operation completes.
-   * Copies will be made of the handler as required. The equivalent function
-   * signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes read.
+   *   std::size_t bytes_transferred // Number of bytes read.
    * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
+   * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
    *
    * @note The async_read_some operation may not read all of the requested
    * number of bytes. Consider using the @ref async_read function if you need to
    * ensure that the requested amount of data is read before the asynchronous
    * operation completes.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * if they are also supported by the @c Stream type's @c async_read_some and
+   * @c async_write_some operations.
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_read_some(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_read_some(this), handler, buffers);
+        initiate_async_read_some(this), token, buffers);
   }
 
 private:
diff --git a/boost/asio/ssl/stream_base.hpp b/boost/asio/ssl/stream_base.hpp
index c5993ca2bc480e65a5e743cce6243f7623bd0ba7..cbf9b7573be041045789b3df91d65e79a90a098f 100644
--- a/boost/asio/ssl/stream_base.hpp
+++ b/boost/asio/ssl/stream_base.hpp
@@ -2,7 +2,7 @@
 // ssl/stream_base.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/verify_context.hpp b/boost/asio/ssl/verify_context.hpp
index 237e9f01fac46cc2252653f5a9f576cd561f6c59..3d1f5ae600cb53d08067624854c454b350da9a1e 100644
--- a/boost/asio/ssl/verify_context.hpp
+++ b/boost/asio/ssl/verify_context.hpp
@@ -2,7 +2,7 @@
 // ssl/verify_context.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ssl/verify_mode.hpp b/boost/asio/ssl/verify_mode.hpp
index 56059e6a5d8a92f621b57b7faabab38ad35478f6..18ceb733d2a6f01a7fa212161453086df5ab7330 100644
--- a/boost/asio/ssl/verify_mode.hpp
+++ b/boost/asio/ssl/verify_mode.hpp
@@ -2,7 +2,7 @@
 // ssl/verify_mode.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/static_thread_pool.hpp b/boost/asio/static_thread_pool.hpp
index 4245d1d114d1356e96b6af0478c26b9d22f84fed..0e022419d4693de2ef70e9d829f260f70bfaaf38 100644
--- a/boost/asio/static_thread_pool.hpp
+++ b/boost/asio/static_thread_pool.hpp
@@ -2,7 +2,7 @@
 // static_thread_pool.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/steady_timer.hpp b/boost/asio/steady_timer.hpp
index dd846f4fb98abb520377a39d7e2342147b15264f..6a6ce57501fbeea01e446e1ae42f4de33d1fa881 100644
--- a/boost/asio/steady_timer.hpp
+++ b/boost/asio/steady_timer.hpp
@@ -2,7 +2,7 @@
 // steady_timer.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/strand.hpp b/boost/asio/strand.hpp
index 6d6f5a5ba6fa3eaaf1fd78d81b3e726061fc3e16..ddbf9204b3db26c7731bf6607317e9c56b4222d1 100644
--- a/boost/asio/strand.hpp
+++ b/boost/asio/strand.hpp
@@ -2,7 +2,7 @@
 // strand.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/stream_file.hpp b/boost/asio/stream_file.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..0b83cd3616840abae586a9150e2dfffa686f0774
--- /dev/null
+++ b/boost/asio/stream_file.hpp
@@ -0,0 +1,37 @@
+//
+// stream_file.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_STREAM_FILE_HPP
+#define BOOST_ASIO_STREAM_FILE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_FILE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <boost/asio/basic_stream_file.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Typedef for the typical usage of a stream-oriented file.
+typedef basic_stream_file<> stream_file;
+
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_STREAM_FILE_HPP
diff --git a/boost/asio/streambuf.hpp b/boost/asio/streambuf.hpp
index e980487dd345833af9f572312d5ec9a5680005cc..4e0f656ea61b8c4ac2ffbdd133b65e26a270941e 100644
--- a/boost/asio/streambuf.hpp
+++ b/boost/asio/streambuf.hpp
@@ -2,7 +2,7 @@
 // streambuf.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/system_context.hpp b/boost/asio/system_context.hpp
index 52d67e1c7dd748847aba2a4ddeb47640ebacd4a7..1f47ec464c2333a4c0cda213b03d54fadbf239d5 100644
--- a/boost/asio/system_context.hpp
+++ b/boost/asio/system_context.hpp
@@ -2,7 +2,7 @@
 // system_context.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/system_executor.hpp b/boost/asio/system_executor.hpp
index 3e60328e271adac4ec35dfe181f244f59d3d0272..e84b5ba49dae8727364e54ebdb21b5ab3714814e 100644
--- a/boost/asio/system_executor.hpp
+++ b/boost/asio/system_executor.hpp
@@ -2,7 +2,7 @@
 // system_executor.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -47,8 +47,8 @@ public:
 
 #if !defined(GENERATING_DOCUMENTATION)
 private:
-  friend struct asio_require_fn::impl;
-  friend struct asio_prefer_fn::impl;
+  friend struct boost_asio_require_fn::impl;
+  friend struct boost_asio_prefer_fn::impl;
 #endif // !defined(GENERATING_DOCUMENTATION)
 
   /// Obtain an executor with the @c blocking.possibly property.
@@ -178,7 +178,7 @@ private:
 
 #if !defined(GENERATING_DOCUMENTATION)
 private:
-  friend struct asio_query_fn::impl;
+  friend struct boost_asio_query_fn::impl;
   friend struct boost::asio::execution::detail::blocking_t<0>;
   friend struct boost::asio::execution::detail::mapping_t<0>;
   friend struct boost::asio::execution::detail::outstanding_work_t<0>;
@@ -317,7 +317,7 @@ public:
 
 #if !defined(GENERATING_DOCUMENTATION)
 private:
-  friend struct asio_execution_execute_fn::impl;
+  friend struct boost_asio_execution_execute_fn::impl;
 #endif // !defined(GENERATING_DOCUMENTATION)
 
   /// Execution function.
diff --git a/boost/asio/system_timer.hpp b/boost/asio/system_timer.hpp
index 4561c9032e6862ea34a847fd2dc6cff58655b18b..b5b1e6e4e9a9b82d72084acfcd9da3090070f77a 100644
--- a/boost/asio/system_timer.hpp
+++ b/boost/asio/system_timer.hpp
@@ -2,7 +2,7 @@
 // system_timer.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/this_coro.hpp b/boost/asio/this_coro.hpp
index 6cccc22731dfc9f3e32bcd4286c81beab1b0bc1a..6d5f9b087909ae7556eeffbd9b740277749d84ac 100644
--- a/boost/asio/this_coro.hpp
+++ b/boost/asio/this_coro.hpp
@@ -2,7 +2,7 @@
 // this_coro.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,6 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -38,6 +39,240 @@ constexpr executor_t executor;
 __declspec(selectany) executor_t executor;
 #endif
 
+/// Awaitable type that returns the cancellation state of the current coroutine.
+struct cancellation_state_t
+{
+  BOOST_ASIO_CONSTEXPR cancellation_state_t()
+  {
+  }
+};
+
+/// Awaitable object that returns the cancellation state of the current
+/// coroutine.
+/**
+ * @par Example
+ * @code boost::asio::awaitable<void> my_coroutine()
+ * {
+ *   boost::asio::cancellation_state cs
+ *     = co_await boost::asio::this_coro::cancellation_state;
+ *
+ *   // ...
+ *
+ *   if (cs.cancelled() != boost::asio::cancellation_type::none)
+ *     // ...
+ * } @endcode
+ */
+#if defined(BOOST_ASIO_HAS_CONSTEXPR) || defined(GENERATING_DOCUMENTATION)
+constexpr cancellation_state_t cancellation_state;
+#elif defined(BOOST_ASIO_MSVC)
+__declspec(selectany) cancellation_state_t cancellation_state;
+#endif
+
+#if defined(GENERATING_DOCUMENTATION)
+
+/// Returns an awaitable object that may be used to reset the cancellation state
+/// of the current coroutine.
+/**
+ * Let <tt>P</tt> be the cancellation slot associated with the current
+ * coroutine's `co_spawn` completion handler. Assigns a new
+ * boost::asio::cancellation_state object <tt>S</tt>, constructed as
+ * <tt>S(P)</tt>, into the current coroutine's cancellation state object.
+ *
+ * @par Example
+ * @code boost::asio::awaitable<void> my_coroutine()
+ * {
+ *   co_await boost::asio::this_coro::reset_cancellation_state();
+ *
+ *   // ...
+ * } @endcode
+ *
+ * @note The cancellation state is shared by all coroutines in the same "thread
+ * of execution" that was created using boost::asio::co_spawn.
+ */
+BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR unspecified
+reset_cancellation_state();
+
+/// Returns an awaitable object that may be used to reset the cancellation state
+/// of the current coroutine.
+/**
+ * Let <tt>P</tt> be the cancellation slot associated with the current
+ * coroutine's `co_spawn` completion handler. Assigns a new
+ * boost::asio::cancellation_state object <tt>S</tt>, constructed as <tt>S(P,
+ * std::forward<Filter>(filter))</tt>, into the current coroutine's
+ * cancellation state object.
+ *
+ * @par Example
+ * @code boost::asio::awaitable<void> my_coroutine()
+ * {
+ *   co_await boost::asio::this_coro::reset_cancellation_state(
+ *       boost::asio::enable_partial_cancellation());
+ *
+ *   // ...
+ * } @endcode
+ *
+ * @note The cancellation state is shared by all coroutines in the same "thread
+ * of execution" that was created using boost::asio::co_spawn.
+ */
+template <typename Filter>
+BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR unspecified
+reset_cancellation_state(BOOST_ASIO_MOVE_ARG(Filter) filter);
+
+/// Returns an awaitable object that may be used to reset the cancellation state
+/// of the current coroutine.
+/**
+ * Let <tt>P</tt> be the cancellation slot associated with the current
+ * coroutine's `co_spawn` completion handler. Assigns a new
+ * boost::asio::cancellation_state object <tt>S</tt>, constructed as <tt>S(P,
+ * std::forward<InFilter>(in_filter),
+ * std::forward<OutFilter>(out_filter))</tt>, into the current coroutine's
+ * cancellation state object.
+ *
+ * @par Example
+ * @code boost::asio::awaitable<void> my_coroutine()
+ * {
+ *   co_await boost::asio::this_coro::reset_cancellation_state(
+ *       boost::asio::enable_partial_cancellation(),
+ *       boost::asio::disable_cancellation());
+ *
+ *   // ...
+ * } @endcode
+ *
+ * @note The cancellation state is shared by all coroutines in the same "thread
+ * of execution" that was created using boost::asio::co_spawn.
+ */
+template <typename InFilter, typename OutFilter>
+BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR unspecified
+reset_cancellation_state(
+    BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
+    BOOST_ASIO_MOVE_ARG(OutFilter) out_filter);
+
+/// Returns an awaitable object that may be used to determine whether the
+/// coroutine throws if trying to suspend when it has been cancelled.
+/**
+ * @par Example
+ * @code boost::asio::awaitable<void> my_coroutine()
+ * {
+ *   if (co_await boost::asio::this_coro::throw_if_cancelled)
+ *     // ...
+ *
+ *   // ...
+ * } @endcode
+ */
+BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR unspecified
+throw_if_cancelled();
+
+/// Returns an awaitable object that may be used to specify whether the
+/// coroutine throws if trying to suspend when it has been cancelled.
+/**
+ * @par Example
+ * @code boost::asio::awaitable<void> my_coroutine()
+ * {
+ *   co_await boost::asio::this_coro::throw_if_cancelled(false);
+ *
+ *   // ...
+ * } @endcode
+ */
+BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR unspecified
+throw_if_cancelled(bool value);
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+struct reset_cancellation_state_0_t
+{
+  BOOST_ASIO_CONSTEXPR reset_cancellation_state_0_t()
+  {
+  }
+};
+
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONSTEXPR reset_cancellation_state_0_t
+reset_cancellation_state()
+{
+  return reset_cancellation_state_0_t();
+}
+
+template <typename Filter>
+struct reset_cancellation_state_1_t
+{
+  template <typename F>
+  BOOST_ASIO_CONSTEXPR reset_cancellation_state_1_t(
+      BOOST_ASIO_MOVE_ARG(F) filt)
+    : filter(BOOST_ASIO_MOVE_CAST(F)(filt))
+  {
+  }
+
+  Filter filter;
+};
+
+template <typename Filter>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONSTEXPR reset_cancellation_state_1_t<
+    typename decay<Filter>::type>
+reset_cancellation_state(BOOST_ASIO_MOVE_ARG(Filter) filter)
+{
+  return reset_cancellation_state_1_t<typename decay<Filter>::type>(
+      BOOST_ASIO_MOVE_CAST(Filter)(filter));
+}
+
+template <typename InFilter, typename OutFilter>
+struct reset_cancellation_state_2_t
+{
+  template <typename F1, typename F2>
+  BOOST_ASIO_CONSTEXPR reset_cancellation_state_2_t(
+      BOOST_ASIO_MOVE_ARG(F1) in_filt, BOOST_ASIO_MOVE_ARG(F2) out_filt)
+    : in_filter(BOOST_ASIO_MOVE_CAST(F1)(in_filt)),
+      out_filter(BOOST_ASIO_MOVE_CAST(F2)(out_filt))
+  {
+  }
+
+  InFilter in_filter;
+  OutFilter out_filter;
+};
+
+template <typename InFilter, typename OutFilter>
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONSTEXPR reset_cancellation_state_2_t<
+    typename decay<InFilter>::type,
+    typename decay<OutFilter>::type>
+reset_cancellation_state(
+    BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
+    BOOST_ASIO_MOVE_ARG(OutFilter) out_filter)
+{
+  return reset_cancellation_state_2_t<
+      typename decay<InFilter>::type,
+      typename decay<OutFilter>::type>(
+        BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
+        BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter));
+}
+
+struct throw_if_cancelled_0_t
+{
+  BOOST_ASIO_CONSTEXPR throw_if_cancelled_0_t()
+  {
+  }
+};
+
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONSTEXPR throw_if_cancelled_0_t
+throw_if_cancelled()
+{
+  return throw_if_cancelled_0_t();
+}
+
+struct throw_if_cancelled_1_t
+{
+  BOOST_ASIO_CONSTEXPR throw_if_cancelled_1_t(bool val)
+    : value(val)
+  {
+  }
+
+  bool value;
+};
+
+BOOST_ASIO_NODISCARD inline BOOST_ASIO_CONSTEXPR throw_if_cancelled_1_t
+throw_if_cancelled(bool value)
+{
+  return throw_if_cancelled_1_t(value);
+}
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
 } // namespace this_coro
 } // namespace asio
 } // namespace boost
diff --git a/boost/asio/thread_pool.hpp b/boost/asio/thread_pool.hpp
index 5397e434b13690380cd87fecefe05df37bdfbb17..ee551e9f1b5c3e6fb3b1e5654cc515b3879f528b 100644
--- a/boost/asio/thread_pool.hpp
+++ b/boost/asio/thread_pool.hpp
@@ -2,7 +2,7 @@
 // thread_pool.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -233,8 +233,8 @@ public:
 
 #if !defined(GENERATING_DOCUMENTATION)
 private:
-  friend struct asio_require_fn::impl;
-  friend struct asio_prefer_fn::impl;
+  friend struct boost_asio_require_fn::impl;
+  friend struct boost_asio_prefer_fn::impl;
 #endif // !defined(GENERATING_DOCUMENTATION)
 
   /// Obtain an executor with the @c blocking.possibly property.
@@ -399,7 +399,7 @@ private:
 
 #if !defined(GENERATING_DOCUMENTATION)
 private:
-  friend struct asio_query_fn::impl;
+  friend struct boost_asio_query_fn::impl;
   friend struct boost::asio::execution::detail::mapping_t<0>;
   friend struct boost::asio::execution::detail::outstanding_work_t<0>;
 #endif // !defined(GENERATING_DOCUMENTATION)
@@ -594,7 +594,7 @@ public:
 
 #if !defined(GENERATING_DOCUMENTATION)
 private:
-  friend struct asio_execution_execute_fn::impl;
+  friend struct boost_asio_execution_execute_fn::impl;
 #endif // !defined(GENERATING_DOCUMENTATION)
 
   /// Execution function.
@@ -1118,6 +1118,15 @@ struct query_member<
 
 } // namespace traits
 
+namespace execution {
+
+template <>
+struct is_executor<thread_pool> : false_type
+{
+};
+
+} // namespace execution
+
 #endif // !defined(GENERATING_DOCUMENTATION)
 
 } // namespace asio
diff --git a/boost/asio/time_traits.hpp b/boost/asio/time_traits.hpp
index d0aa5f83838f85d8acda13c8467d4a1dd3ef997e..c5dd10869b719c13ce3648e86cf3dee2fe859ac0 100644
--- a/boost/asio/time_traits.hpp
+++ b/boost/asio/time_traits.hpp
@@ -2,7 +2,7 @@
 // time_traits.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/bulk_execute_free.hpp b/boost/asio/traits/bulk_execute_free.hpp
index d42db4e4003a3572c226d90a90d9fc224fcb6cea..b055be523b23232ab5ab1cf060e9d355fe6478ce 100644
--- a/boost/asio/traits/bulk_execute_free.hpp
+++ b/boost/asio/traits/bulk_execute_free.hpp
@@ -2,7 +2,7 @@
 // traits/bulk_execute_free.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/bulk_execute_member.hpp b/boost/asio/traits/bulk_execute_member.hpp
index d923618b4dbdbe348f1a189021a5695bb6ec8c81..e02dbe61a19f086fa482920c43fa31fd66fede30 100644
--- a/boost/asio/traits/bulk_execute_member.hpp
+++ b/boost/asio/traits/bulk_execute_member.hpp
@@ -2,7 +2,7 @@
 // traits/bulk_execute_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/connect_free.hpp b/boost/asio/traits/connect_free.hpp
index 88a1c1b2071c8cc5e705cb634b0fe091c581de37..bad6f99326bc4d954b78343226754450e5d0a494 100644
--- a/boost/asio/traits/connect_free.hpp
+++ b/boost/asio/traits/connect_free.hpp
@@ -2,7 +2,7 @@
 // traits/connect_free.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/connect_member.hpp b/boost/asio/traits/connect_member.hpp
index 8d907f7640d03471fc710589f4c430e8280f3b0c..63bb3fa820b3d65910d4ef60f4178f87d90fd3f8 100644
--- a/boost/asio/traits/connect_member.hpp
+++ b/boost/asio/traits/connect_member.hpp
@@ -2,7 +2,7 @@
 // traits/connect_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/equality_comparable.hpp b/boost/asio/traits/equality_comparable.hpp
index 685713ea6390242135ff5eda37dd6224470630ef..9ec39bbdfc85ae3f12675e24d787db0209d68748 100644
--- a/boost/asio/traits/equality_comparable.hpp
+++ b/boost/asio/traits/equality_comparable.hpp
@@ -2,7 +2,7 @@
 // traits/equality_comparable.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/execute_free.hpp b/boost/asio/traits/execute_free.hpp
index 56acc2a10277bd42b1bc746d08e0b95e1e2a9481..642ffb974fb3cec571ac605569210998e5ebbffa 100644
--- a/boost/asio/traits/execute_free.hpp
+++ b/boost/asio/traits/execute_free.hpp
@@ -2,7 +2,7 @@
 // traits/execute_free.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/execute_member.hpp b/boost/asio/traits/execute_member.hpp
index 24a80a5d361e5dbb29b12ff95b1df1f7c3dd11e9..2038f41866f272d06fadac2f6e49a777c634cb8c 100644
--- a/boost/asio/traits/execute_member.hpp
+++ b/boost/asio/traits/execute_member.hpp
@@ -2,7 +2,7 @@
 // traits/execute_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/prefer_free.hpp b/boost/asio/traits/prefer_free.hpp
index c534f3f43849d3b2d83f11c33474eac8f79b8431..8d79c2147b78d1d43101fac7659bc1c110b0f57a 100644
--- a/boost/asio/traits/prefer_free.hpp
+++ b/boost/asio/traits/prefer_free.hpp
@@ -2,7 +2,7 @@
 // traits/prefer_free.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/prefer_member.hpp b/boost/asio/traits/prefer_member.hpp
index 496b41761f2b6416c8e13b0021e6c31945d0ac76..848693ed80d67087e43e4cb56372cbc4612cdbb4 100644
--- a/boost/asio/traits/prefer_member.hpp
+++ b/boost/asio/traits/prefer_member.hpp
@@ -2,7 +2,7 @@
 // traits/prefer_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/query_free.hpp b/boost/asio/traits/query_free.hpp
index 8cac82d41e930a0376e999d22b4b59ff677f0cf4..5d0ded7ca73cc02810e56498c963e9442effb8b1 100644
--- a/boost/asio/traits/query_free.hpp
+++ b/boost/asio/traits/query_free.hpp
@@ -2,7 +2,7 @@
 // traits/query_free.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/query_member.hpp b/boost/asio/traits/query_member.hpp
index 3017db0f6851d8b65684413f1103ce9f48c6d146..deca0d811f64ec7d7d03e7de4cd4d8e0cef1278f 100644
--- a/boost/asio/traits/query_member.hpp
+++ b/boost/asio/traits/query_member.hpp
@@ -2,7 +2,7 @@
 // traits/query_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/query_static_constexpr_member.hpp b/boost/asio/traits/query_static_constexpr_member.hpp
index ec0ce0d738d35e5da9dd83c20105537608f0f6b6..5ea5252184b0d5c5886aed989fb57fe9b4ef6b1b 100644
--- a/boost/asio/traits/query_static_constexpr_member.hpp
+++ b/boost/asio/traits/query_static_constexpr_member.hpp
@@ -2,7 +2,7 @@
 // traits/query_static_constexpr_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/require_concept_free.hpp b/boost/asio/traits/require_concept_free.hpp
index 2011c75235524ccc336ac724c0299cd6ae1168f7..31523050f980f6a8bbbb006e37e9b913be9a83db 100644
--- a/boost/asio/traits/require_concept_free.hpp
+++ b/boost/asio/traits/require_concept_free.hpp
@@ -2,7 +2,7 @@
 // traits/require_concept_free.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/require_concept_member.hpp b/boost/asio/traits/require_concept_member.hpp
index 541ceaaedaa246ecfc5d45cb62dbeb24149bba67..3c91c57f3f475d1fb70adfd4222aa804d92eb3ef 100644
--- a/boost/asio/traits/require_concept_member.hpp
+++ b/boost/asio/traits/require_concept_member.hpp
@@ -2,7 +2,7 @@
 // traits/require_concept_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/require_free.hpp b/boost/asio/traits/require_free.hpp
index 38fbd918b28c9494dd62f5019d18593ee918ad28..39b71b91fb636362035b68365ecdb1fde750a49e 100644
--- a/boost/asio/traits/require_free.hpp
+++ b/boost/asio/traits/require_free.hpp
@@ -2,7 +2,7 @@
 // traits/require_free.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/require_member.hpp b/boost/asio/traits/require_member.hpp
index 25b3df76c6380050b1e9b72a58c3cc53d24d8137..df959faeb44a0c9a94902a721e1f9992ffbe5704 100644
--- a/boost/asio/traits/require_member.hpp
+++ b/boost/asio/traits/require_member.hpp
@@ -2,7 +2,7 @@
 // traits/require_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/schedule_free.hpp b/boost/asio/traits/schedule_free.hpp
index 76d55d63133db023f2b1e3368995f8081f2d4efa..9d163f80298e260791a7fa0053eae12039811c20 100644
--- a/boost/asio/traits/schedule_free.hpp
+++ b/boost/asio/traits/schedule_free.hpp
@@ -2,7 +2,7 @@
 // traits/schedule_free.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/schedule_member.hpp b/boost/asio/traits/schedule_member.hpp
index b5a1facf9a42bd91de0d73366dbe6b019e982005..2f334a66cb956a45b029627877345388e16186c9 100644
--- a/boost/asio/traits/schedule_member.hpp
+++ b/boost/asio/traits/schedule_member.hpp
@@ -2,7 +2,7 @@
 // traits/schedule_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/set_done_free.hpp b/boost/asio/traits/set_done_free.hpp
index 4c86011bda15329b4d0cede09b644266b4d35ad8..eb2b2f7289b908046d1877b90b39ea541092f960 100644
--- a/boost/asio/traits/set_done_free.hpp
+++ b/boost/asio/traits/set_done_free.hpp
@@ -2,7 +2,7 @@
 // traits/set_done_free.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/set_done_member.hpp b/boost/asio/traits/set_done_member.hpp
index 2c8b981aef7eff786abda4dcae8b29709a109001..a32d3cbc5838d01f869d22dc7181349e3c969a60 100644
--- a/boost/asio/traits/set_done_member.hpp
+++ b/boost/asio/traits/set_done_member.hpp
@@ -2,7 +2,7 @@
 // traits/set_done_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/set_error_free.hpp b/boost/asio/traits/set_error_free.hpp
index f950ee92a10a42125955b460007c099d322ec162..55924e7dc89ee47805baf1bc3902db45b1b92167 100644
--- a/boost/asio/traits/set_error_free.hpp
+++ b/boost/asio/traits/set_error_free.hpp
@@ -2,7 +2,7 @@
 // traits/set_error_free.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/set_error_member.hpp b/boost/asio/traits/set_error_member.hpp
index e7df5dc9e531c934e76502605425595395757397..5160c6ef9739833a2216922e59bf08491680b716 100644
--- a/boost/asio/traits/set_error_member.hpp
+++ b/boost/asio/traits/set_error_member.hpp
@@ -2,7 +2,7 @@
 // traits/set_error_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/set_value_free.hpp b/boost/asio/traits/set_value_free.hpp
index 2d2e5561c989d401fccc9f0c3f7c5c5cbf6ade92..bb1bab9b2273c05cd1a03bae55a8102f8eafe946 100644
--- a/boost/asio/traits/set_value_free.hpp
+++ b/boost/asio/traits/set_value_free.hpp
@@ -2,7 +2,7 @@
 // traits/set_value_free.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/set_value_member.hpp b/boost/asio/traits/set_value_member.hpp
index 5ceddad5f6338b8b93a551cdb2a8e02afd9a4161..0d7583334a1d5ed4d0ca31362a09d36312bb9334 100644
--- a/boost/asio/traits/set_value_member.hpp
+++ b/boost/asio/traits/set_value_member.hpp
@@ -2,7 +2,7 @@
 // traits/set_value_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/start_free.hpp b/boost/asio/traits/start_free.hpp
index 00ab86b91a55d1cc9c9cabb30a7840162802fc28..34c8479394a084b49bf01ac59f6d5a55836a64fa 100644
--- a/boost/asio/traits/start_free.hpp
+++ b/boost/asio/traits/start_free.hpp
@@ -2,7 +2,7 @@
 // traits/start_free.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/start_member.hpp b/boost/asio/traits/start_member.hpp
index 9c9045e7b183728807d48bfb0bc57e1ce3f26ec8..8d3882fcaee156faccf1cd75aa0470e5ef461c7d 100644
--- a/boost/asio/traits/start_member.hpp
+++ b/boost/asio/traits/start_member.hpp
@@ -2,7 +2,7 @@
 // traits/start_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/static_query.hpp b/boost/asio/traits/static_query.hpp
index b51bc56b5a92790f42a2fda9859383fd584f6f4f..aa7979b7036b4952a75758b3e8a9e713f64ce78c 100644
--- a/boost/asio/traits/static_query.hpp
+++ b/boost/asio/traits/static_query.hpp
@@ -2,7 +2,7 @@
 // traits/static_query.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/static_require.hpp b/boost/asio/traits/static_require.hpp
index 1b2812f07ddcc386e30c765b913946abaa85ddf8..964494274add5ae0aaa0f91e0762bff0c617a123 100644
--- a/boost/asio/traits/static_require.hpp
+++ b/boost/asio/traits/static_require.hpp
@@ -2,7 +2,7 @@
 // traits/static_require.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/static_require_concept.hpp b/boost/asio/traits/static_require_concept.hpp
index ca4d7df37b0d934301d2e2f039f2d61343347c02..b27327e731a9b41a49edfbef0c22824bdbdf2081 100644
--- a/boost/asio/traits/static_require_concept.hpp
+++ b/boost/asio/traits/static_require_concept.hpp
@@ -2,7 +2,7 @@
 // traits/static_require_concept.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/submit_free.hpp b/boost/asio/traits/submit_free.hpp
index 1a8bee2cdbb2997866ff83e7c72f060ccfd8d5b5..565ce156d2257f95591ecf404803654130d5cafa 100644
--- a/boost/asio/traits/submit_free.hpp
+++ b/boost/asio/traits/submit_free.hpp
@@ -2,7 +2,7 @@
 // traits/submit_free.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/traits/submit_member.hpp b/boost/asio/traits/submit_member.hpp
index 76c4ffdb5bbb9c0a80647166e12ad9a4a8019b25..d409c38b0c7b6b1ae16899830b43db44e99141da 100644
--- a/boost/asio/traits/submit_member.hpp
+++ b/boost/asio/traits/submit_member.hpp
@@ -2,7 +2,7 @@
 // traits/submit_member.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ts/buffer.hpp b/boost/asio/ts/buffer.hpp
index 4283730fdaa8aa18e9dcd6dde9acbfd2faa9d3ce..840b17e2d28a7a7b1763f8aa898e06b33174abd6 100644
--- a/boost/asio/ts/buffer.hpp
+++ b/boost/asio/ts/buffer.hpp
@@ -2,7 +2,7 @@
 // ts/buffer.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ts/executor.hpp b/boost/asio/ts/executor.hpp
index 3099ee3ff6cf8b805dbc9ee5bda50ba1c4478ca2..f3c674b08be42fbea126a11a9ce362cf4f7683db 100644
--- a/boost/asio/ts/executor.hpp
+++ b/boost/asio/ts/executor.hpp
@@ -2,7 +2,7 @@
 // ts/executor.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ts/internet.hpp b/boost/asio/ts/internet.hpp
index 90fc10064e013a81c9dc2c38b3d6de46217150e2..4b07bb0790d64d13482e6cca933819f4d91c55a5 100644
--- a/boost/asio/ts/internet.hpp
+++ b/boost/asio/ts/internet.hpp
@@ -2,7 +2,7 @@
 // ts/internet.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ts/io_context.hpp b/boost/asio/ts/io_context.hpp
index 7bc0883eb20fa77c76ba46bb4dcc3b1115b6580b..ed27e0536eb29b20eb0bdbad65c965fd6c947029 100644
--- a/boost/asio/ts/io_context.hpp
+++ b/boost/asio/ts/io_context.hpp
@@ -2,7 +2,7 @@
 // ts/io_context.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ts/net.hpp b/boost/asio/ts/net.hpp
index cb26b16738d581f413b43e90a5f94431efd73be7..394f6ff4a5c10ba1788653c89d4415ad23dc3fab 100644
--- a/boost/asio/ts/net.hpp
+++ b/boost/asio/ts/net.hpp
@@ -2,7 +2,7 @@
 // ts/net.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ts/netfwd.hpp b/boost/asio/ts/netfwd.hpp
index 2d6cc7b4e566322b09c1b16cb81e7c5dc8780c30..4aac37479e82d26b4feb25540061277eb4c2abb6 100644
--- a/boost/asio/ts/netfwd.hpp
+++ b/boost/asio/ts/netfwd.hpp
@@ -2,7 +2,7 @@
 // ts/netfwd.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ts/socket.hpp b/boost/asio/ts/socket.hpp
index e87d49cb4f4421317b1a5f851f00d829335c9f52..ea69c530655514578c52a2cca7c12c6ae55c54dd 100644
--- a/boost/asio/ts/socket.hpp
+++ b/boost/asio/ts/socket.hpp
@@ -2,7 +2,7 @@
 // ts/socket.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/ts/timer.hpp b/boost/asio/ts/timer.hpp
index a9dea9602f713b08824036d1e581e4354c1022df..17cc6815643341ab449c6f999cb758d16cc3cc9f 100644
--- a/boost/asio/ts/timer.hpp
+++ b/boost/asio/ts/timer.hpp
@@ -2,7 +2,7 @@
 // ts/timer.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/unyield.hpp b/boost/asio/unyield.hpp
index 983a000546e06c985a28de1b725479e3ea1b4253..f09a2fd71fe131954a4ae45a56fb2a80ce8e12c3 100644
--- a/boost/asio/unyield.hpp
+++ b/boost/asio/unyield.hpp
@@ -2,7 +2,7 @@
 // unyield.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/use_awaitable.hpp b/boost/asio/use_awaitable.hpp
index 4f13c8f6eacbb9bec869c3c5a624942648b532c6..78c44f057830f597a9a7ec088616d2994b643b12 100644
--- a/boost/asio/use_awaitable.hpp
+++ b/boost/asio/use_awaitable.hpp
@@ -2,7 +2,7 @@
 // use_awaitable.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -100,17 +100,14 @@ struct use_awaitable_t
     typedef use_awaitable_t default_completion_token_type;
 
     /// Construct the adapted executor from the inner executor type.
-    executor_with_default(const InnerExecutor& ex) BOOST_ASIO_NOEXCEPT
-      : InnerExecutor(ex)
-    {
-    }
-
-    /// Convert the specified executor to the inner executor type, then use
-    /// that to construct the adapted executor.
-    template <typename OtherExecutor>
-    executor_with_default(const OtherExecutor& ex,
+    template <typename InnerExecutor1>
+    executor_with_default(const InnerExecutor1& ex,
         typename constraint<
-          is_convertible<OtherExecutor, InnerExecutor>::value
+          conditional<
+            !is_same<InnerExecutor1, executor_with_default>::value,
+            is_convertible<InnerExecutor1, InnerExecutor>,
+            false_type
+          >::type::value
         >::type = 0) BOOST_ASIO_NOEXCEPT
       : InnerExecutor(ex)
     {
diff --git a/boost/asio/use_future.hpp b/boost/asio/use_future.hpp
index d73ba244ca1e9a2d31d029447405a82cc0307dcd..a8d9a96f4c1510d4dc867b3d524aa0ca70a3f7e9 100644
--- a/boost/asio/use_future.hpp
+++ b/boost/asio/use_future.hpp
@@ -2,7 +2,7 @@
 // use_future.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -38,12 +38,14 @@ class packaged_handler;
 
 } // namespace detail
 
-/// Class used to specify that an asynchronous operation should return a future.
+/// A completion token type that causes an asynchronous operation to return a
+/// future.
 /**
- * The use_future_t class is used to indicate that an asynchronous operation
- * should return a std::future object. A use_future_t object may be passed as a
- * handler to an asynchronous operation, typically using the special value @c
- * boost::asio::use_future. For example:
+ * The use_future_t class is a completion token type that is used to indicate
+ * that an asynchronous operation should return a std::future object. A
+ * use_future_t object may be passed as a completion token to an asynchronous
+ * operation, typically using the special value @c boost::asio::use_future. For
+ * example:
  *
  * @code std::future<std::size_t> my_future
  *   = my_socket.async_read_some(my_buffer, boost::asio::use_future); @endcode
@@ -139,7 +141,8 @@ private:
     std_allocator_void, Allocator>::type allocator_;
 };
 
-/// A special value, similar to std::nothrow.
+/// A completion token object that causes an asynchronous operation to return a
+/// future.
 /**
  * See the documentation for boost::asio::use_future_t for a usage example.
  */
diff --git a/boost/asio/uses_executor.hpp b/boost/asio/uses_executor.hpp
index 2c5a18b3a9c893713170dfe80eeab94e931f0576..111aef06a7f7da12dab2f8f3594d38e16757545f 100644
--- a/boost/asio/uses_executor.hpp
+++ b/boost/asio/uses_executor.hpp
@@ -2,7 +2,7 @@
 // uses_executor.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/version.hpp b/boost/asio/version.hpp
index 771e3930c64d91b2ae7354f69f6c72eb62a8893c..9b18c1cfb07d0cbee1f5d922e88f14fd664e8bc1 100644
--- a/boost/asio/version.hpp
+++ b/boost/asio/version.hpp
@@ -2,7 +2,7 @@
 // version.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,6 +18,6 @@
 // BOOST_ASIO_VERSION % 100 is the sub-minor version
 // BOOST_ASIO_VERSION / 100 % 1000 is the minor version
 // BOOST_ASIO_VERSION / 100000 is the major version
-#define BOOST_ASIO_VERSION 101802 // 1.18.2
+#define BOOST_ASIO_VERSION 102201 // 1.22.1
 
 #endif // BOOST_ASIO_VERSION_HPP
diff --git a/boost/asio/wait_traits.hpp b/boost/asio/wait_traits.hpp
index 307d6e44f2c8e6857062f6b049d1d202dd88b578..42a9047f922a76b9029c51a3dc20eecdd5baa4fe 100644
--- a/boost/asio/wait_traits.hpp
+++ b/boost/asio/wait_traits.hpp
@@ -2,7 +2,7 @@
 // wait_traits.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/windows/basic_object_handle.hpp b/boost/asio/windows/basic_object_handle.hpp
index a37ddbe6ca3d5c150609a1bc76b5c4a412ccccba..b5358d807e643327c861445bfb8b57f2c976bd8e 100644
--- a/boost/asio/windows/basic_object_handle.hpp
+++ b/boost/asio/windows/basic_object_handle.hpp
@@ -2,7 +2,7 @@
 // windows/basic_object_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -358,30 +358,36 @@ public:
   /// Start an asynchronous wait on the object handle.
   /**
    * This function is be used to initiate an asynchronous wait against the
-   * object handle. It always returns immediately.
+   * object handle. It is an initiating function for an @ref
+   * asynchronous_operation, and always returns immediately.
    *
-   * @param handler The handler to be called when the object handle is set to
-   * the signalled state. Copies will be made of the handler as required. The
-   * function signature of the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the wait completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
+   *
+   * @par Completion Signature
+   * @code void(boost::system::error_code) @endcode
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
-        WaitHandler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitHandler,
+        WaitToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitToken,
       void (boost::system::error_code))
   async_wait(
-      BOOST_ASIO_MOVE_ARG(WaitHandler) handler
+      BOOST_ASIO_MOVE_ARG(WaitToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WaitHandler, void (boost::system::error_code)>(
-        initiate_async_wait(this), handler);
+    return async_initiate<WaitToken, void (boost::system::error_code)>(
+        initiate_async_wait(this), token);
   }
 
 private:
diff --git a/boost/asio/windows/basic_overlapped_handle.hpp b/boost/asio/windows/basic_overlapped_handle.hpp
index a1303228343dbd26a40796160fc85d35890b0538..29c06d16340bf3d36c6fe10aead6ca97ceab9496 100644
--- a/boost/asio/windows/basic_overlapped_handle.hpp
+++ b/boost/asio/windows/basic_overlapped_handle.hpp
@@ -2,7 +2,7 @@
 // windows/basic_overlapped_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/windows/basic_random_access_handle.hpp b/boost/asio/windows/basic_random_access_handle.hpp
index dfd17bc17aebaf4987d44b2bf1022b569425a053..991faad7fe6b3eaadd8e34ff667fb128b446f9ca 100644
--- a/boost/asio/windows/basic_random_access_handle.hpp
+++ b/boost/asio/windows/basic_random_access_handle.hpp
@@ -2,7 +2,7 @@
 // windows/basic_random_access_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -76,8 +76,8 @@ public:
   /// Construct a random-access handle without opening it.
   /**
    * This constructor creates a random-access handle without opening it. The
-   * handle needs to be opened or assigned before data can be sent or received
-   * on it.
+   * handle needs to be opened or assigned before data can be written to or read
+   * from it.
    *
    * @param context An execution context which provides the I/O executor that
    * the random-access handle will use, by default, to dispatch handlers for any
@@ -240,27 +240,33 @@ public:
   /// Start an asynchronous write at the specified offset.
   /**
    * This function is used to asynchronously write data to the random-access
-   * handle. The function call always returns immediately.
+   * handle. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param offset The offset at which the data will be written.
    *
    * @param buffers One or more data buffers to be written to the handle.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the write operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes written.
+   *   std::size_t bytes_transferred // Number of bytes written.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write_at function if you need to ensure that
    * all data is written before the asynchronous operation completes.
@@ -273,21 +279,31 @@ public:
    * See the @ref buffer documentation for information on writing multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_write_some_at(uint64_t offset,
       const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_write_some_at(this), handler, offset, buffers);
+        initiate_async_write_some_at(this), token, offset, buffers);
   }
 
   /// Read some data from the handle at the specified offset.
@@ -361,27 +377,33 @@ public:
   /// Start an asynchronous read at the specified offset.
   /**
    * This function is used to asynchronously read data from the random-access
-   * handle. The function call always returns immediately.
+   * handle. It is an initiating function for an @ref asynchronous_operation,
+   * and always returns immediately.
    *
    * @param offset The offset at which the data will be read.
    *
    * @param buffers One or more buffers into which the data will be read.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the read operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes read.
+   *   std::size_t bytes_transferred // Number of bytes read.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read_at function if you need to ensure that
    * the requested amount of data is read before the asynchronous operation
@@ -395,21 +417,31 @@ public:
    * See the @ref buffer documentation for information on reading into multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_read_some_at(uint64_t offset,
       const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_read_some_at(this), handler, offset, buffers);
+        initiate_async_read_some_at(this), token, offset, buffers);
   }
 
 private:
diff --git a/boost/asio/windows/basic_stream_handle.hpp b/boost/asio/windows/basic_stream_handle.hpp
index 990bf8db0cf01e96dd7ec91e81af64c677bafa06..9884c2241873a2d9ba69afeef3bc1d3a3706f8c3 100644
--- a/boost/asio/windows/basic_stream_handle.hpp
+++ b/boost/asio/windows/basic_stream_handle.hpp
@@ -2,7 +2,7 @@
 // windows/basic_stream_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -79,7 +79,8 @@ public:
   /// Construct a stream handle without opening it.
   /**
    * This constructor creates a stream handle without opening it. The handle
-   * needs to be opened or assigned before data can be sent or received on it.
+   * needs to be opened or assigned before data can be written to or read from
+   * it.
    *
    * @param context An execution context which provides the I/O executor that
    * the stream handle will use, by default, to dispatch handlers for any
@@ -235,25 +236,31 @@ public:
   /// Start an asynchronous write.
   /**
    * This function is used to asynchronously write data to the stream handle.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more data buffers to be written to the handle.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the write operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the write completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes written.
+   *   std::size_t bytes_transferred // Number of bytes written.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
@@ -266,20 +273,30 @@ public:
    * See the @ref buffer documentation for information on writing multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) WriteHandler
+        std::size_t)) WriteToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
       void (boost::system::error_code, std::size_t))
   async_write_some(const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+      BOOST_ASIO_MOVE_ARG(WriteToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<WriteHandler,
+    return async_initiate<WriteToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_write_some(this), handler, buffers);
+        initiate_async_write_some(this), token, buffers);
   }
 
   /// Read some data from the handle.
@@ -348,25 +365,31 @@ public:
   /// Start an asynchronous read.
   /**
    * This function is used to asynchronously read data from the stream handle.
-   * The function call always returns immediately.
+   * It is an initiating function for an @ref asynchronous_operation, and always
+   * returns immediately.
    *
    * @param buffers One or more buffers into which the data will be read.
    * Although the buffers object may be copied as necessary, ownership of the
    * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
+   * that they remain valid until the completion handler is called.
    *
-   * @param handler The handler to be called when the read operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
+   * @param token The @ref completion_token that will be used to produce a
+   * completion handler, which will be called when the read completes.
+   * Potential completion tokens include @ref use_future, @ref use_awaitable,
+   * @ref yield_context, or a function object with the correct completion
+   * signature. The function signature of the completion handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes read.
+   *   std::size_t bytes_transferred // Number of bytes read.
    * ); @endcode
    * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. On
-   * immediate completion, invocation of the handler will be performed in a
+   * not, the completion handler will not be invoked from within this function.
+   * On immediate completion, invocation of the handler will be performed in a
    * manner equivalent to using boost::asio::post().
    *
+   * @par Completion Signature
+   * @code void(boost::system::error_code, std::size_t) @endcode
+   *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
    * requested amount of data is read before the asynchronous operation
@@ -380,20 +403,30 @@ public:
    * See the @ref buffer documentation for information on reading into multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * @li @c cancellation_type::total
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-        std::size_t)) ReadHandler
+        std::size_t)) ReadToken
           BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
       void (boost::system::error_code, std::size_t))
   async_read_some(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler
+      BOOST_ASIO_MOVE_ARG(ReadToken) token
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
   {
-    return async_initiate<ReadHandler,
+    return async_initiate<ReadToken,
       void (boost::system::error_code, std::size_t)>(
-        initiate_async_read_some(this), handler, buffers);
+        initiate_async_read_some(this), token, buffers);
   }
 
 private:
diff --git a/boost/asio/windows/object_handle.hpp b/boost/asio/windows/object_handle.hpp
index a15c9d9be5349e76ee843fd28eb5f150be0ad406..41afcff9b350dce14c306972c8b26f0ffeddaf6c 100644
--- a/boost/asio/windows/object_handle.hpp
+++ b/boost/asio/windows/object_handle.hpp
@@ -2,7 +2,7 @@
 // windows/object_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 // Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/boost/asio/windows/overlapped_handle.hpp b/boost/asio/windows/overlapped_handle.hpp
index 5ccc8b768623e5a8b172a60ce1299968c9990e54..b2dd5b9750814c83e314ad6932afbc0a8651d892 100644
--- a/boost/asio/windows/overlapped_handle.hpp
+++ b/boost/asio/windows/overlapped_handle.hpp
@@ -2,7 +2,7 @@
 // windows/overlapped_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/windows/overlapped_ptr.hpp b/boost/asio/windows/overlapped_ptr.hpp
index 299a4a4d8b30f2545dd16ca22386c996685a1761..ac709ed1c430ebd41f33ad463a48cb5d8640894a 100644
--- a/boost/asio/windows/overlapped_ptr.hpp
+++ b/boost/asio/windows/overlapped_ptr.hpp
@@ -2,7 +2,7 @@
 // windows/overlapped_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/windows/random_access_handle.hpp b/boost/asio/windows/random_access_handle.hpp
index 8692bc14322a257f5fc1efd6a7b31fa1aff8f92d..3a61db8e2ef7aadef87adb8e3b1a6d675b2fe26e 100644
--- a/boost/asio/windows/random_access_handle.hpp
+++ b/boost/asio/windows/random_access_handle.hpp
@@ -2,7 +2,7 @@
 // windows/random_access_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/windows/stream_handle.hpp b/boost/asio/windows/stream_handle.hpp
index a7ae638848e3dac3a4148ef1e8c483dc9641963a..a7253382c6964301e2c9ffa5e4627f0a85bcc515 100644
--- a/boost/asio/windows/stream_handle.hpp
+++ b/boost/asio/windows/stream_handle.hpp
@@ -2,7 +2,7 @@
 // windows/stream_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/asio/writable_pipe.hpp b/boost/asio/writable_pipe.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..9b52a099f2b6379f7c9fedbfd8e22211bb79acf0
--- /dev/null
+++ b/boost/asio/writable_pipe.hpp
@@ -0,0 +1,37 @@
+//
+// writable_pipe.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_WRITABLE_PIPE_HPP
+#define BOOST_ASIO_WRITABLE_PIPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_PIPE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <boost/asio/basic_writable_pipe.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Typedef for the typical usage of a writable pipe.
+typedef basic_writable_pipe<> writable_pipe;
+
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_ASIO_HAS_PIPE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_WRITABLE_PIPE_HPP
diff --git a/boost/asio/write.hpp b/boost/asio/write.hpp
index 11dd505197bfd42f297cf1c0a179a01838a2adc7..b19e7ce45ce82471716e8a6b6ff245880d162f4c 100644
--- a/boost/asio/write.hpp
+++ b/boost/asio/write.hpp
@@ -2,7 +2,7 @@
 // write.hpp
 // ~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -714,9 +714,9 @@ std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
 /// stream.
 /**
  * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * data to a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li All of the data in the supplied buffers has been written. That is, the
  * bytes transferred is equal to the sum of the buffer sizes.
@@ -735,24 +735,29 @@ std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
  * @param buffers One or more buffers containing the data to be written.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
- * @param handler The handler to be called when the write operation completes.
- * Copies will be made of the handler as required. The function signature of
- * the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the write completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes written from the
- *                                           // buffers. If an error occurred,
- *                                           // this will be less than the sum
- *                                           // of the buffer sizes.
+ *   // Number of bytes written from the buffers. If an error
+ *   // occurred, this will be less than the sum of the buffer sizes.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
  * @code
@@ -761,16 +766,27 @@ std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
  * See the @ref buffer documentation for information on writing multiple
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncWriteStream type's
+ * @c async_write_some operation.
  */
 template <typename AsyncWriteStream, typename ConstBufferSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler
+      std::size_t)) WriteToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncWriteStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+    BOOST_ASIO_MOVE_ARG(WriteToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncWriteStream::executor_type),
     typename constraint<
@@ -781,9 +797,9 @@ async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
 /// stream.
 /**
  * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * data to a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li All of the data in the supplied buffers has been written. That is, the
  * bytes transferred is equal to the sum of the buffer sizes.
@@ -802,7 +818,7 @@ async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
  * @param buffers One or more buffers containing the data to be written.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
@@ -818,22 +834,27 @@ async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
  * non-zero return value indicates the maximum number of bytes to be written on
  * the next call to the stream's async_write_some function.
  *
- * @param handler The handler to be called when the write operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the write completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes written from the
- *                                           // buffers. If an error occurred,
- *                                           // this will be less than the sum
- *                                           // of the buffer sizes.
+ *   // Number of bytes written from the buffers. If an error
+ *   // occurred, this will be less than the sum of the buffer sizes.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::async_write(s,
@@ -843,16 +864,27 @@ async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
  * See the @ref buffer documentation for information on writing multiple
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+   *
+ * if they are also supported by the @c AsyncWriteStream type's
+ * @c async_write_some operation.
  */
 template <typename AsyncWriteStream,
     typename ConstBufferSequence, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+    BOOST_ASIO_MOVE_ARG(WriteToken) token,
     typename constraint<
       is_const_buffer_sequence<ConstBufferSequence>::value
     >::type = 0);
@@ -863,9 +895,9 @@ async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
 /// stream.
 /**
  * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * data to a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li All of the data in the supplied dynamic buffer sequence has been written.
  *
@@ -883,35 +915,51 @@ async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
  * @param buffers The dynamic buffer sequence from which data will be written.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called. Successfully written
- * data is automatically consumed from the buffers.
- *
- * @param handler The handler to be called when the write operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * that they remain valid until the completion handler is called. Successfully
+ * written data is automatically consumed from the buffers.
+ *
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the write completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes written from the
- *                                           // buffers. If an error occurred,
- *                                           // this will be less than the sum
- *                                           // of the buffer sizes.
+ *   // Number of bytes written from the buffers. If an error
+ *   // occurred, this will be less than the sum of the buffer sizes.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
+ *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncWriteStream type's
+ * @c async_write_some operation.
  */
 template <typename AsyncWriteStream, typename DynamicBuffer_v1,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler
+      std::size_t)) WriteToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncWriteStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+    BOOST_ASIO_MOVE_ARG(WriteToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncWriteStream::executor_type),
     typename constraint<
@@ -925,9 +973,9 @@ async_write(AsyncWriteStream& s,
 /// stream.
 /**
  * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * data to a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li All of the data in the supplied dynamic buffer sequence has been written.
  *
@@ -945,8 +993,8 @@ async_write(AsyncWriteStream& s,
  * @param buffers The dynamic buffer sequence from which data will be written.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called. Successfully written
- * data is automatically consumed from the buffers.
+ * that they remain valid until the completion handler is called. Successfully
+ * written data is automatically consumed from the buffers.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
@@ -962,32 +1010,48 @@ async_write(AsyncWriteStream& s,
  * non-zero return value indicates the maximum number of bytes to be written on
  * the next call to the stream's async_write_some function.
  *
- * @param handler The handler to be called when the write operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the write completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes written from the
- *                                           // buffers. If an error occurred,
- *                                           // this will be less than the sum
- *                                           // of the buffer sizes.
+ *   // Number of bytes written from the buffers. If an error
+ *   // occurred, this will be less than the sum of the buffer sizes.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
+ *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncWriteStream type's
+ * @c async_write_some operation.
  */
 template <typename AsyncWriteStream,
     typename DynamicBuffer_v1, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s,
     BOOST_ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+    BOOST_ASIO_MOVE_ARG(WriteToken) token,
     typename constraint<
       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value
     >::type = 0,
@@ -1002,9 +1066,9 @@ async_write(AsyncWriteStream& s,
 /// stream.
 /**
  * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * data to a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li All of the data in the supplied basic_streambuf has been written.
  *
@@ -1021,33 +1085,49 @@ async_write(AsyncWriteStream& s,
  *
  * @param b A basic_streambuf object from which data will be written. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the handler is called.
+ * remains valid until the completion handler is called.
  *
- * @param handler The handler to be called when the write operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the write completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes written from the
- *                                           // buffers. If an error occurred,
- *                                           // this will be less than the sum
- *                                           // of the buffer sizes.
+ *   // Number of bytes written from the buffers. If an error
+ *   // occurred, this will be less than the sum of the buffer sizes.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
+ *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncWriteStream type's
+ * @c async_write_some operation.
  */
 template <typename AsyncWriteStream, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler
+      std::size_t)) WriteToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncWriteStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+    BOOST_ASIO_MOVE_ARG(WriteToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncWriteStream::executor_type));
 
@@ -1055,9 +1135,9 @@ async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
 /// stream.
 /**
  * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * data to a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li All of the data in the supplied basic_streambuf has been written.
  *
@@ -1074,7 +1154,7 @@ async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
  *
  * @param b A basic_streambuf object from which data will be written. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the handler is called.
+ * remains valid until the completion handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
@@ -1090,31 +1170,47 @@ async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
  * non-zero return value indicates the maximum number of bytes to be written on
  * the next call to the stream's async_write_some function.
  *
- * @param handler The handler to be called when the write operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the write completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes written from the
- *                                           // buffers. If an error occurred,
- *                                           // this will be less than the sum
- *                                           // of the buffer sizes.
+ *   // Number of bytes written from the buffers. If an error
+ *   // occurred, this will be less than the sum of the buffer sizes.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
+ *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncWriteStream type's
+ * @c async_write_some operation.
  */
 template <typename AsyncWriteStream,
     typename Allocator, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
+    BOOST_ASIO_MOVE_ARG(WriteToken) token);
 
 #endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 #endif // !defined(BOOST_ASIO_NO_EXTENSIONS)
@@ -1124,9 +1220,9 @@ async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
 /// stream.
 /**
  * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * data to a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li All of the data in the supplied dynamic buffer sequence has been written.
  *
@@ -1144,34 +1240,50 @@ async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
  * @param buffers The dynamic buffer sequence from which data will be written.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called. Successfully written
- * data is automatically consumed from the buffers.
- *
- * @param handler The handler to be called when the write operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * that they remain valid until the completion handler is called. Successfully
+ * written data is automatically consumed from the buffers.
+ *
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the write completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes written from the
- *                                           // buffers. If an error occurred,
- *                                           // this will be less than the sum
- *                                           // of the buffer sizes.
+ *   // Number of bytes written from the buffers. If an error
+ *   // occurred, this will be less than the sum of the buffer sizes.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
+ *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncWriteStream type's
+ * @c async_write_some operation.
  */
 template <typename AsyncWriteStream, typename DynamicBuffer_v2,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler
+      std::size_t)) WriteToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncWriteStream::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+    BOOST_ASIO_MOVE_ARG(WriteToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncWriteStream::executor_type),
     typename constraint<
@@ -1182,9 +1294,9 @@ async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
 /// stream.
 /**
  * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. The function call always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
+ * data to a stream. It is an initiating function for an @ref
+ * asynchronous_operation, and always returns immediately. The asynchronous
+ * operation will continue until one of the following conditions is true:
  *
  * @li All of the data in the supplied dynamic buffer sequence has been written.
  *
@@ -1202,8 +1314,8 @@ async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
  * @param buffers The dynamic buffer sequence from which data will be written.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called. Successfully written
- * data is automatically consumed from the buffers.
+ * that they remain valid until the completion handler is called. Successfully
+ * written data is automatically consumed from the buffers.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
@@ -1219,31 +1331,47 @@ async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
  * non-zero return value indicates the maximum number of bytes to be written on
  * the next call to the stream's async_write_some function.
  *
- * @param handler The handler to be called when the write operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the write completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
- *   const boost::system::error_code& error, // Result of operation.
+ *   // Result of operation.
+ *   const boost::system::error_code& error,
  *
- *   std::size_t bytes_transferred           // Number of bytes written from the
- *                                           // buffers. If an error occurred,
- *                                           // this will be less than the sum
- *                                           // of the buffer sizes.
+ *   // Number of bytes written from the buffers. If an error
+ *   // occurred, this will be less than the sum of the buffer sizes.
+ *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
+ *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncWriteStream type's
+ * @c async_write_some operation.
  */
 template <typename AsyncWriteStream,
     typename DynamicBuffer_v2, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+      std::size_t)) WriteToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
+    BOOST_ASIO_MOVE_ARG(WriteToken) token,
     typename constraint<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
     >::type = 0);
diff --git a/boost/asio/write_at.hpp b/boost/asio/write_at.hpp
index 680ac007a10449854dc0f7102d64483ccbcba981..71ac50567396aba44118e222324e04a47a933476 100644
--- a/boost/asio/write_at.hpp
+++ b/boost/asio/write_at.hpp
@@ -2,7 +2,7 @@
 // write_at.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -404,9 +404,10 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
 /// specified offset.
 /**
  * This function is used to asynchronously write a certain number of bytes of
- * data to a random access device at a specified offset. The function call
- * always returns immediately. The asynchronous operation will continue until
- * one of the following conditions is true:
+ * data to a random access device at a specified offset. It is an initiating
+ * function for an @ref asynchronous_operation, and always returns immediately.
+ * The asynchronous operation will continue until one of the following
+ * conditions is true:
  *
  * @li All of the data in the supplied buffers has been written. That is, the
  * bytes transferred is equal to the sum of the buffer sizes.
@@ -429,11 +430,13 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
  * @param buffers One or more buffers containing the data to be written.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
- * @param handler The handler to be called when the write operation completes.
- * Copies will be made of the handler as required. The function signature of
- * the handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the write completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -443,10 +446,13 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
  * @code
@@ -455,17 +461,28 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
  * See the @ref buffer documentation for information on writing multiple
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncRandomAccessWriteDevice type's
+ * async_write_some_at operation.
  */
 template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler
+      std::size_t)) WriteToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncRandomAccessWriteDevice::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
     const ConstBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+    BOOST_ASIO_MOVE_ARG(WriteToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncRandomAccessWriteDevice::executor_type));
 
@@ -473,9 +490,10 @@ async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
 /// specified offset.
 /**
  * This function is used to asynchronously write a certain number of bytes of
- * data to a random access device at a specified offset. The function call
- * always returns immediately. The asynchronous operation will continue until
- * one of the following conditions is true:
+ * data to a random access device at a specified offset. It is an initiating
+ * function for an @ref asynchronous_operation, and always returns immediately.
+ * The asynchronous operation will continue until one of the following
+ * conditions is true:
  *
  * @li All of the data in the supplied buffers has been written. That is, the
  * bytes transferred is equal to the sum of the buffer sizes.
@@ -498,7 +516,7 @@ async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
  * @param buffers One or more buffers containing the data to be written.
  * Although the buffers object may be copied as necessary, ownership of the
  * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
+ * that they remain valid until the completion handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
@@ -514,9 +532,11 @@ async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
  * non-zero return value indicates the maximum number of bytes to be written on
  * the next call to the device's async_write_some_at function.
  *
- * @param handler The handler to be called when the write operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the write completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -526,10 +546,13 @@ async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
  *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::async_write_at(d, 42,
@@ -539,19 +562,30 @@ async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
  * See the @ref buffer documentation for information on writing multiple
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncRandomAccessWriteDevice type's
+ * async_write_some_at operation.
  */
 template <typename AsyncRandomAccessWriteDevice,
     typename ConstBufferSequence, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler
+      std::size_t)) WriteToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncRandomAccessWriteDevice::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write_at(AsyncRandomAccessWriteDevice& d,
     uint64_t offset, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+    BOOST_ASIO_MOVE_ARG(WriteToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncRandomAccessWriteDevice::executor_type));
 
@@ -562,9 +596,10 @@ async_write_at(AsyncRandomAccessWriteDevice& d,
 /// specified offset.
 /**
  * This function is used to asynchronously write a certain number of bytes of
- * data to a random access device at a specified offset. The function call
- * always returns immediately. The asynchronous operation will continue until
- * one of the following conditions is true:
+ * data to a random access device at a specified offset. It is an initiating
+ * function for an @ref asynchronous_operation, and always returns immediately.
+ * The asynchronous operation will continue until one of the following
+ * conditions is true:
  *
  * @li All of the data in the supplied basic_streambuf has been written.
  *
@@ -585,11 +620,13 @@ async_write_at(AsyncRandomAccessWriteDevice& d,
  *
  * @param b A basic_streambuf object from which data will be written. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the handler is called.
+ * remains valid until the completion handler is called.
  *
- * @param handler The handler to be called when the write operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the write completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -599,20 +636,34 @@ async_write_at(AsyncRandomAccessWriteDevice& d,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
+ *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncRandomAccessWriteDevice type's
+ * async_write_some_at operation.
  */
 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler
+      std::size_t)) WriteToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncRandomAccessWriteDevice::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write_at(AsyncRandomAccessWriteDevice& d,
     uint64_t offset, basic_streambuf<Allocator>& b,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+    BOOST_ASIO_MOVE_ARG(WriteToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncRandomAccessWriteDevice::executor_type));
 
@@ -620,9 +671,10 @@ async_write_at(AsyncRandomAccessWriteDevice& d,
 /// specified offset.
 /**
  * This function is used to asynchronously write a certain number of bytes of
- * data to a random access device at a specified offset. The function call
- * always returns immediately. The asynchronous operation will continue until
- * one of the following conditions is true:
+ * data to a random access device at a specified offset. It is an initiating
+ * function for an @ref asynchronous_operation, and always returns immediately.
+ * The asynchronous operation will continue until one of the following
+ * conditions is true:
  *
  * @li All of the data in the supplied basic_streambuf has been written.
  *
@@ -643,7 +695,7 @@ async_write_at(AsyncRandomAccessWriteDevice& d,
  *
  * @param b A basic_streambuf object from which data will be written. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the handler is called.
+ * remains valid until the completion handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
@@ -659,9 +711,11 @@ async_write_at(AsyncRandomAccessWriteDevice& d,
  * non-zero return value indicates the maximum number of bytes to be written on
  * the next call to the device's async_write_some_at function.
  *
- * @param handler The handler to be called when the write operation completes.
- * Copies will be made of the handler as required. The function signature of the
- * handler must be:
+ * @param token The @ref completion_token that will be used to produce a
+ * completion handler, which will be called when the write completes.
+ * Potential completion tokens include @ref use_future, @ref use_awaitable,
+ * @ref yield_context, or a function object with the correct completion
+ * signature. The function signature of the completion handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
@@ -671,21 +725,35 @@ async_write_at(AsyncRandomAccessWriteDevice& d,
  *   std::size_t bytes_transferred
  * ); @endcode
  * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. On
- * immediate completion, invocation of the handler will be performed in a
+ * not, the completion handler will not be invoked from within this function.
+ * On immediate completion, invocation of the handler will be performed in a
  * manner equivalent to using boost::asio::post().
+ *
+ * @par Completion Signature
+ * @code void(boost::system::error_code, std::size_t) @endcode
+ *
+ * @par Per-Operation Cancellation
+ * This asynchronous operation supports cancellation for the following
+ * boost::asio::cancellation_type values:
+ *
+ * @li @c cancellation_type::terminal
+ *
+ * @li @c cancellation_type::partial
+ *
+ * if they are also supported by the @c AsyncRandomAccessWriteDevice type's
+ * async_write_some_at operation.
  */
 template <typename AsyncRandomAccessWriteDevice,
     typename Allocator, typename CompletionCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      std::size_t)) WriteHandler
+      std::size_t)) WriteToken
         BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
           typename AsyncRandomAccessWriteDevice::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
     void (boost::system::error_code, std::size_t))
 async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
     basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler
+    BOOST_ASIO_MOVE_ARG(WriteToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename AsyncRandomAccessWriteDevice::executor_type));
 
diff --git a/boost/asio/yield.hpp b/boost/asio/yield.hpp
index 5f9ddd007b9d2e0f4e44ee75a8e958d138443ee9..4c1c68681d14166768f3f26472c25cd4ae5b464a 100644
--- a/boost/asio/yield.hpp
+++ b/boost/asio/yield.hpp
@@ -2,7 +2,7 @@
 // yield.hpp
 // ~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/boost/beast/_experimental/test/detail/stream_state.hpp b/boost/beast/_experimental/test/detail/stream_state.hpp
index 5df55cf3f9cfb3bada8cee4011daccf39f40f5f1..0cfdb88052529b5df5a7e681bbb4f6f8fbf33057 100644
--- a/boost/beast/_experimental/test/detail/stream_state.hpp
+++ b/boost/beast/_experimental/test/detail/stream_state.hpp
@@ -12,7 +12,10 @@
 #define BOOST_BEAST_TEST_DETAIL_STREAM_STATE_HPP
 
 #include <boost/asio/any_io_executor.hpp>
+#include <boost/beast/core/detail/config.hpp>
+#include <boost/beast/_experimental/test/fail_count.hpp>
 #include <boost/beast/core/detail/service_base.hpp>
+#include <boost/beast/core/flat_buffer.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
 
 #include <condition_variable>
diff --git a/boost/beast/_experimental/test/detail/stream_state.ipp b/boost/beast/_experimental/test/detail/stream_state.ipp
index c86c7e97777f2638bc0a8d055fec679af96ce369..268c76051c6e69f3d2df62c736292f236cdaa3ec 100644
--- a/boost/beast/_experimental/test/detail/stream_state.ipp
+++ b/boost/beast/_experimental/test/detail/stream_state.ipp
@@ -12,6 +12,7 @@
 #define BOOST_BEAST_TEST_DETAIL_STREAM_STATE_IPP
 
 #include <boost/beast/_experimental/test/error.hpp>
+#include <boost/make_shared.hpp>
 
 namespace boost {
 namespace beast {
diff --git a/boost/beast/_experimental/test/stream.hpp b/boost/beast/_experimental/test/stream.hpp
index f96269234b99fb856cf52b3caf4c2ba3a4112fdf..5e3a6e74158ce62e1184dd4bf65a718cc43e898f 100644
--- a/boost/beast/_experimental/test/stream.hpp
+++ b/boost/beast/_experimental/test/stream.hpp
@@ -214,7 +214,7 @@ public:
     : in_(std::move(other.in_))
     , out_(std::move(other.out_))
     {
-        assert(in_->exec.target_type() == typeid(Executor2));
+        BOOST_ASSERT(in_->exec.template target<Executor2>() != nullptr);
         in_->exec = executor_type(*in_->exec.template target<Executor2>());
     }
 
@@ -591,7 +591,7 @@ beast_close_socket(basic_stream<Executor>& s)
 */
 template<class Executor>
 template<class... Args>
-bascic_stream
+basic_stream
 connect(basic_stream& to, Args&&... args);
 
 #else
diff --git a/boost/beast/_experimental/unit_test/suite_list.hpp b/boost/beast/_experimental/unit_test/suite_list.hpp
index 93ab16a4311e25a7c8d258eb5b52f66791c56618..bb1fc93a760796da4b6e717a44161d88ad88f45f 100644
--- a/boost/beast/_experimental/unit_test/suite_list.hpp
+++ b/boost/beast/_experimental/unit_test/suite_list.hpp
@@ -13,6 +13,8 @@
 #include <boost/beast/_experimental/unit_test/suite_info.hpp>
 #include <boost/beast/_experimental/unit_test/detail/const_container.hpp>
 #include <boost/assert.hpp>
+#include <boost/type_index.hpp>
+#include <boost/functional/hash.hpp>
 #include <typeindex>
 #include <set>
 #include <unordered_set>
@@ -28,7 +30,9 @@ class suite_list
 private:
 #ifndef NDEBUG
     std::unordered_set<std::string> names_;
-    std::unordered_set<std::type_index> classes_;
+
+    using type_index = boost::typeindex::type_index;
+    std::unordered_set<type_index, boost::hash<type_index>> classes_;
 #endif
 
 public:
@@ -65,7 +69,7 @@ suite_list::insert(
 
     {
         auto const result(classes_.insert(
-            std::type_index(typeid(Suite))));
+            boost::typeindex::type_id<Suite>()));
         BOOST_ASSERT(result.second); // Duplicate type
     }
 #endif
diff --git a/boost/beast/core/file_win32.hpp b/boost/beast/core/file_win32.hpp
index 908076d7fed78d317878a6d129b6730c29531759..e83202cfadac2866fe70411b4930c543c52352db 100644
--- a/boost/beast/core/file_win32.hpp
+++ b/boost/beast/core/file_win32.hpp
@@ -13,7 +13,7 @@
 #include <boost/beast/core/detail/config.hpp>
 
 #if ! defined(BOOST_BEAST_USE_WIN32_FILE)
-# ifdef BOOST_MSVC
+# ifdef _WIN32
 #  define BOOST_BEAST_USE_WIN32_FILE 1
 # else
 #  define BOOST_BEAST_USE_WIN32_FILE 0
diff --git a/boost/beast/core/impl/file_posix.ipp b/boost/beast/core/impl/file_posix.ipp
index 61a33a521062c4dadd05dca02fc8804eebd0053c..e8fa900e0c2f56a734fb347b892b2ed2fb6791e2 100644
--- a/boost/beast/core/impl/file_posix.ipp
+++ b/boost/beast/core/impl/file_posix.ipp
@@ -165,7 +165,7 @@ open(char const* path, file_mode mode, error_code& ec)
         break;
 
     case file_mode::append:         
-        f = O_WRONLY | O_CREAT | O_TRUNC;
+        f = O_WRONLY | O_CREAT | O_APPEND;
     #if BOOST_BEAST_USE_POSIX_FADVISE
         advise = POSIX_FADV_SEQUENTIAL;
     #endif
@@ -270,8 +270,12 @@ read(void* buffer, std::size_t n, error_code& ec) const
     std::size_t nread = 0;
     while(n > 0)
     {
-        auto const amount = static_cast<ssize_t>((std::min)(
-            n, static_cast<std::size_t>(SSIZE_MAX)));
+        // <limits> not required to define SSIZE_MAX so we avoid it
+        constexpr auto ssmax =
+            static_cast<std::size_t>((std::numeric_limits<
+                decltype(::read(fd_, buffer, n))>::max)());
+        auto const amount = (std::min)(
+            n, ssmax);
         auto const result = ::read(fd_, buffer, amount);
         if(result == -1)
         {
@@ -305,8 +309,12 @@ write(void const* buffer, std::size_t n, error_code& ec)
     std::size_t nwritten = 0;
     while(n > 0)
     {
-        auto const amount = static_cast<ssize_t>((std::min)(
-            n, static_cast<std::size_t>(SSIZE_MAX)));
+        // <limits> not required to define SSIZE_MAX so we avoid it
+        constexpr auto ssmax =
+            static_cast<std::size_t>((std::numeric_limits<
+                decltype(::write(fd_, buffer, n))>::max)());
+        auto const amount = (std::min)(
+            n, ssmax);
         auto const result = ::write(fd_, buffer, amount);
         if(result == -1)
         {
diff --git a/boost/beast/core/impl/file_stdio.ipp b/boost/beast/core/impl/file_stdio.ipp
index 301a7e8124015fb4b668228ac6f72273e02e699a..69dbcfed5886b0d2f85279e5436ed7c9cedec20f 100644
--- a/boost/beast/core/impl/file_stdio.ipp
+++ b/boost/beast/core/impl/file_stdio.ipp
@@ -81,7 +81,7 @@ open(char const* path, file_mode mode, error_code& ec)
         f_ = nullptr;
     }
     ec = {};
-#ifdef BOOST_MSVC
+#if defined(BOOST_MSVC) || defined(_MSVC_STL_VERSION)
     boost::winapi::WCHAR_ const* s;
     detail::win32_unicode_path unicode_path(path, ec);
     if (ec)
@@ -93,7 +93,7 @@ open(char const* path, file_mode mode, error_code& ec)
     {
     default:
     case file_mode::read:
-    #ifdef BOOST_MSVC
+    #if defined(BOOST_MSVC) || defined(_MSVC_STL_VERSION)
         s = L"rb";
     #else
         s = "rb";
@@ -101,7 +101,7 @@ open(char const* path, file_mode mode, error_code& ec)
         break;
 
     case file_mode::scan:
-    #ifdef BOOST_MSVC
+    #if defined(BOOST_MSVC) || defined(_MSVC_STL_VERSION)
         s = L"rbS";
     #else
         s = "rb";
@@ -109,7 +109,7 @@ open(char const* path, file_mode mode, error_code& ec)
         break;
 
     case file_mode::write:
-    #ifdef BOOST_MSVC
+    #if defined(BOOST_MSVC) || defined(_MSVC_STL_VERSION)
         s = L"wb+";
     #else
         s = "wb+";
@@ -118,7 +118,10 @@ open(char const* path, file_mode mode, error_code& ec)
 
     case file_mode::write_new:
     {
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1910)
+#if defined(BOOST_MSVC) || defined(_MSVC_STL_VERSION)
+# if (defined(BOOST_MSVC) && BOOST_MSVC >= 1910) || (defined(_MSVC_STL_VERSION) && _MSVC_STL_VERSION >= 141)
+        s = L"wbx";
+# else
         std::FILE* f0;
         auto const ev = ::_wfopen_s(&f0, unicode_path.c_str(), L"rb");
         if(! ev)
@@ -134,8 +137,7 @@ open(char const* path, file_mode mode, error_code& ec)
             return;
         }
         s = L"wb";
-#elif defined(BOOST_MSVC)
-        s = L"wbx";
+# endif
 #else
         s = "wbx";
 #endif
@@ -143,7 +145,7 @@ open(char const* path, file_mode mode, error_code& ec)
     }
 
     case file_mode::write_existing:
-    #ifdef BOOST_MSVC
+    #if defined(BOOST_MSVC) || defined(_MSVC_STL_VERSION)
         s = L"rb+";
     #else
         s = "rb+";
@@ -151,7 +153,7 @@ open(char const* path, file_mode mode, error_code& ec)
         break;
 
     case file_mode::append:
-    #ifdef BOOST_MSVC
+    #if defined(BOOST_MSVC) || defined(_MSVC_STL_VERSION)
         s = L"ab";
     #else
         s = "ab";
@@ -160,7 +162,7 @@ open(char const* path, file_mode mode, error_code& ec)
 
     case file_mode::append_existing:
     {
-#ifdef BOOST_MSVC
+#if defined(BOOST_MSVC) || defined(_MSVC_STL_VERSION)
         std::FILE* f0;
         auto const ev =
             ::_wfopen_s(&f0, unicode_path.c_str(), L"rb+");
@@ -179,7 +181,7 @@ open(char const* path, file_mode mode, error_code& ec)
         }
 #endif
         std::fclose(f0);
-    #ifdef BOOST_MSVC
+    #if defined(BOOST_MSVC) || defined(_MSVC_STL_VERSION)
         s = L"ab";
     #else
         s = "ab";
@@ -188,7 +190,7 @@ open(char const* path, file_mode mode, error_code& ec)
     }
     }
 
-#ifdef BOOST_MSVC
+#if defined(BOOST_MSVC) || defined(_MSVC_STL_VERSION)
     auto const ev = ::_wfopen_s(&f_, unicode_path.c_str(), s);
     if(ev)
     {
diff --git a/boost/beast/core/impl/file_win32.ipp b/boost/beast/core/impl/file_win32.ipp
index f7b76619795b03b0bb601af1a433c96fd2adc0c7..d7000c5e95253996137caca0710f6b26056320f8 100644
--- a/boost/beast/core/impl/file_win32.ipp
+++ b/boost/beast/core/impl/file_win32.ipp
@@ -175,7 +175,7 @@ open(char const* path, file_mode mode, error_code& ec)
         desired_access = boost::winapi::GENERIC_READ_ |
                          boost::winapi::GENERIC_WRITE_;
 
-        creation_disposition = boost::winapi::CREATE_ALWAYS_;
+        creation_disposition = boost::winapi::OPEN_ALWAYS_;
         flags_and_attributes = 0x08000000; // FILE_FLAG_SEQUENTIAL_SCAN
         break;
 
@@ -198,11 +198,28 @@ open(char const* path, file_mode mode, error_code& ec)
         creation_disposition,
         flags_and_attributes,
         NULL);
-    if(h_ == boost::winapi::INVALID_HANDLE_VALUE_)
+    if (h_ == boost::winapi::INVALID_HANDLE_VALUE_)
+    {
         ec.assign(boost::winapi::GetLastError(),
             system_category());
-    else
-        ec = {};
+        return;
+    }
+    if (mode == file_mode::append ||
+        mode == file_mode::append_existing)
+    {
+        boost::winapi::LARGE_INTEGER_ in;
+        in.QuadPart = 0;
+        if (!detail::set_file_pointer_ex(h_, in, 0,
+            boost::winapi::FILE_END_))
+        {
+            ec.assign(boost::winapi::GetLastError(),
+                system_category());
+            boost::winapi::CloseHandle(h_);
+            h_ = boost::winapi::INVALID_HANDLE_VALUE_;
+            return;
+        }
+    }
+    ec = {};
 }
 
 std::uint64_t
diff --git a/boost/beast/version.hpp b/boost/beast/version.hpp
index b6de4ae47315c22bea3c8937f924d2236835ab8f..330237fc8cfd2aa7c9c218aaed9c202125b32397 100644
--- a/boost/beast/version.hpp
+++ b/boost/beast/version.hpp
@@ -20,7 +20,7 @@
     This is a simple integer that is incremented by one every
     time a set of code changes is merged to the develop branch.
 */
-#define BOOST_BEAST_VERSION 313
+#define BOOST_BEAST_VERSION 329
 
 #define BOOST_BEAST_VERSION_STRING "Boost.Beast/" BOOST_STRINGIZE(BOOST_BEAST_VERSION)
 
diff --git a/boost/beast/websocket/detail/impl_base.hpp b/boost/beast/websocket/detail/impl_base.hpp
index fc5bf0bcecb12974013c6301051f793adefaf47c..009129985f35f551cc343d2f34d46bd2323ea3f7 100644
--- a/boost/beast/websocket/detail/impl_base.hpp
+++ b/boost/beast/websocket/detail/impl_base.hpp
@@ -137,7 +137,7 @@ struct impl_base<true>
                     return false;
                 if(zs.avail_out >= 6)
                 {
-                    zo.write(zs, zlib::Flush::full, ec);
+                    zo.write(zs, zlib::Flush::sync, ec);
                     BOOST_ASSERT(! ec);
                     // remove flush marker
                     zs.total_out -= 4;
diff --git a/boost/beast/websocket/impl/handshake.hpp b/boost/beast/websocket/impl/handshake.hpp
index 2298decf9f38eee23d0b9566d3139afd96a8c5eb..4ad9e3690e16f6b17269f0c2adc21ae0c92b67e6 100644
--- a/boost/beast/websocket/impl/handshake.hpp
+++ b/boost/beast/websocket/impl/handshake.hpp
@@ -225,6 +225,9 @@ do_handshake(
     RequestDecorator const& decorator,
     error_code& ec)
 {
+    if(res_p)
+        res_p->result(http::status::internal_server_error);
+
     auto& impl = *impl_;
     impl.change_status(status::handshake);
     impl.reset();
@@ -275,12 +278,18 @@ do_handshake(
     if(impl.check_stop_now(ec))
         return;
 
-    impl.on_response(p.get(), key, ec);
-    if(impl.check_stop_now(ec))
-        return;
-
-    if(res_p)
+    if (res_p)
+    {
+        // If res_p is not null, move parser's response into it.
         *res_p = p.release();
+    }
+    else
+    {
+        // Otherwise point res_p at the response in the parser.
+        res_p = &p.get();
+    }
+
+    impl.on_response(*res_p, key, ec);
 }
 
 //------------------------------------------------------------------------------
@@ -325,6 +334,7 @@ async_handshake(
     detail::sec_ws_key_type key;
     auto req = impl_->build_request(
         key, host, target, &default_decorate_req);
+    res.result(http::status::internal_server_error);
     return net::async_initiate<
         HandshakeHandler,
         void(error_code)>(
diff --git a/boost/beast/websocket/stream.hpp b/boost/beast/websocket/stream.hpp
index f7c8cab93ec1a21befb88180091a19051f114890..2823e4b10122bf7e9ccce3b12f08c30b48dd0d21 100644
--- a/boost/beast/websocket/stream.hpp
+++ b/boost/beast/websocket/stream.hpp
@@ -675,7 +675,11 @@ public:
 
         @param res The HTTP Upgrade response returned by the remote
         endpoint. The caller may use the response to access any
-        additional information sent by the server.
+        additional information sent by the server. Note that the response object
+        referenced by this parameter will be updated as long as the stream has
+        received a valid HTTP response. If not (for example because of a communications
+        error), the response contents will be undefined except for the result() which
+        will bet set to 500, Internal Server Error.
 
         @param host The name of the remote host. This is required by
         the HTTP protocol to set the "Host" header field.
diff --git a/boost/beast/zlib/detail/inflate_stream.ipp b/boost/beast/zlib/detail/inflate_stream.ipp
index 37955b9c3d4c855310716d97d9dc3baf48c12e6b..42e033ae089fd8260120cdad6f85c493c8beae68 100644
--- a/boost/beast/zlib/detail/inflate_stream.ipp
+++ b/boost/beast/zlib/detail/inflate_stream.ipp
@@ -572,7 +572,7 @@ inflate_table(
     code *next;                     // next available space in table
     std::uint16_t const* base;      // base value table to use
     std::uint16_t const* extra;     // extra bits table to use
-    int end;                        // use base and extra for symbol > end
+    unsigned match;                 // use base and extra for symbol >= match
     std::uint16_t count[15+1];      // number of codes of each length
     std::uint16_t offs[15+1];       // offsets in table for each length
 
@@ -584,7 +584,7 @@ inflate_table(
     // Length codes 257..285 extra
     static std::uint16_t constexpr lext[31] = {
         16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
-        19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78};
+        19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 77, 202};
 
     // Distance codes 0..29 base
     static std::uint16_t constexpr dbase[32] = {
@@ -722,19 +722,17 @@ inflate_table(
     {
     case build::codes:
         base = extra = work;    /* dummy value--not used */
-        end = 19;
+        match = 20;
         break;
     case build::lens:
         base = lbase;
-        base -= 257;
         extra = lext;
-        extra -= 257;
-        end = 256;
+        match = 257;
         break;
     default:            /* build::dists */
         base = dbase;
         extra = dext;
-        end = -1;
+        match = 0;
     }
 
     /* initialize state for loop */
@@ -764,15 +762,15 @@ inflate_table(
     {
         /* create table entry */
         here.bits = (std::uint8_t)(len - drop);
-        if ((int)(work[sym]) < end)
+        if (work[sym] + 1U < match)
         {
             here.op = (std::uint8_t)0;
             here.val = work[sym];
         }
-        else if ((int)(work[sym]) > end)
+        else if (work[sym] >= match)
         {
-            here.op = (std::uint8_t)(extra[work[sym]]);
-            here.val = base[work[sym]];
+            here.op = (std::uint8_t)(extra[work[sym] - match]);
+            here.val = base[work[sym] - match];
         }
         else
         {
diff --git a/boost/hana/accessors.hpp b/boost/hana/accessors.hpp
index 28204b6e31581f63a1c9c88908cce2302f930414..b19ba03f7a3619d247ac33407e7c578922294e97 100644
--- a/boost/hana/accessors.hpp
+++ b/boost/hana/accessors.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/dispatch.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename S>
     struct accessors_t {
     #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
@@ -51,6 +51,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     >>
         : S::hana_accessors_impl
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ACCESSORS_HPP
diff --git a/boost/hana/adjust.hpp b/boost/hana/adjust.hpp
index e8bab2cac3709fc595cc8fa0445c8ef114150963..3067044a4eb928dd8831492411e23236275a6699 100644
--- a/boost/hana/adjust.hpp
+++ b/boost/hana/adjust.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/equal.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Value, typename F>
     constexpr auto adjust_t::operator()(Xs&& xs, Value&& value, F&& f) const {
@@ -50,6 +50,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ADJUST_HPP
diff --git a/boost/hana/adjust_if.hpp b/boost/hana/adjust_if.hpp
index 8669009a9a1b7282173ca353a79688ff6a4f5340..fae64dd3528ad30126081836f863370c0d43cdc5 100644
--- a/boost/hana/adjust_if.hpp
+++ b/boost/hana/adjust_if.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/transform.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred, typename F>
     constexpr auto adjust_if_t::operator()(Xs&& xs, Pred const& pred, F const& f) const {
@@ -73,6 +73,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                    detail::apply_if<Pred, F>{pred, f});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ADJUST_IF_HPP
diff --git a/boost/hana/all.hpp b/boost/hana/all.hpp
index bc952c986ff6715165fb9b6901843828af353518..5ce6d559c5a30d02f145887eb8a5dee42dc0c283 100644
--- a/boost/hana/all.hpp
+++ b/boost/hana/all.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/id.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr auto all_t::operator()(Xs&& xs) const {
@@ -43,6 +43,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr auto apply(Xs&& xs)
         { return hana::all_of(static_cast<Xs&&>(xs), hana::id); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ALL_HPP
diff --git a/boost/hana/all_of.hpp b/boost/hana/all_of.hpp
index 5aff4a01e75e49f8ceda66e6ba965b8b78ba8314..38324432d14c968b078b269cb5951d532e8e9317 100644
--- a/boost/hana/all_of.hpp
+++ b/boost/hana/all_of.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/not.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred>
     constexpr auto all_of_t::operator()(Xs&& xs, Pred&& pred) const {
@@ -46,6 +46,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                     hana::compose(hana::not_, static_cast<Pred&&>(pred))));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ALL_OF_HPP
diff --git a/boost/hana/and.hpp b/boost/hana/and.hpp
index df460d32a660b8038a35ffb88beb6b26bf0563cb..935eb798cb237811a08b2bf94c9dd3a39be8f983 100644
--- a/boost/hana/and.hpp
+++ b/boost/hana/and.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/if.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr decltype(auto) and_t::operator()(X&& x, Y&& y) const {
@@ -53,6 +53,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::if_(x, static_cast<Y&&>(y), x);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_AND_HPP
diff --git a/boost/hana/any.hpp b/boost/hana/any.hpp
index 9141a758df694689ec3abceaad86d6d8d45627b4..556c394c3486f9d90335ea10d299f758a23c333d 100644
--- a/boost/hana/any.hpp
+++ b/boost/hana/any.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/id.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr auto any_t::operator()(Xs&& xs) const {
@@ -43,6 +43,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr auto apply(Xs&& xs)
         { return hana::any_of(static_cast<Xs&&>(xs), hana::id); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ANY_HPP
diff --git a/boost/hana/any_of.hpp b/boost/hana/any_of.hpp
index 59c130e54dad1b400dffac5a9d5167825f91c490..2173cb1b82d54afaaa3314d8a36173222e9f00a0 100644
--- a/boost/hana/any_of.hpp
+++ b/boost/hana/any_of.hpp
@@ -31,7 +31,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred>
     constexpr auto any_of_t::operator()(Xs&& xs, Pred&& pred) const {
@@ -187,6 +187,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                     hana::compose(static_cast<Pred&&>(pred), hana::first));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ANY_OF_HPP
diff --git a/boost/hana/ap.hpp b/boost/hana/ap.hpp
index a96f7d1aa70222b1a6bd0957bb55f3066011758a..eec17b15ccca86557a43536541345bf6ead2f2de 100644
--- a/boost/hana/ap.hpp
+++ b/boost/hana/ap.hpp
@@ -23,7 +23,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/transform.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename A, bool condition>
     struct ap_impl<A, when<condition>> : default_ {
         template <typename ...Args>
@@ -73,6 +73,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_AP_HPP
diff --git a/boost/hana/append.hpp b/boost/hana/append.hpp
index 951f24d35e404aab48f74491333462eb95785f23..d4804ca7a801c92235d8db2e82009c6f41847890 100644
--- a/boost/hana/append.hpp
+++ b/boost/hana/append.hpp
@@ -26,7 +26,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename X>
     constexpr auto append_t::operator()(Xs&& xs, X&& x) const {
@@ -69,6 +69,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                  std::make_index_sequence<N>{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_APPEND_HPP
diff --git a/boost/hana/at.hpp b/boost/hana/at.hpp
index c3f158b0ff3c2f29e307704a712b428a2ab9f947..2c3a6fdbdbb53aa46a8c9e575b8a4eced1abb7a3 100644
--- a/boost/hana/at.hpp
+++ b/boost/hana/at.hpp
@@ -21,7 +21,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename N>
     constexpr decltype(auto) at_t::operator()(Xs&& xs, N const& n) const {
@@ -52,6 +52,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     constexpr decltype(auto) at_c(Xs&& xs) {
         return hana::at(static_cast<Xs&&>(xs), hana::size_t<n>{});
     }
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_AT_HPP
diff --git a/boost/hana/at_key.hpp b/boost/hana/at_key.hpp
index e4f2e112555894477b4f509d375ce2a33bfea2b1..6bef7867d2546aa86cb061abc43956449158464f 100644
--- a/boost/hana/at_key.hpp
+++ b/boost/hana/at_key.hpp
@@ -34,7 +34,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Key>
     constexpr decltype(auto) at_key_t::operator()(Xs&& xs, Key const& key) const {
@@ -92,6 +92,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return accessor(static_cast<X&&>(x));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_AT_KEY_HPP
diff --git a/boost/hana/back.hpp b/boost/hana/back.hpp
index 4fed83f0320597bd8c124d46ffed147dbb331914..ce25c135a663a28f4a6b3f12c426964e5be074a6 100644
--- a/boost/hana/back.hpp
+++ b/boost/hana/back.hpp
@@ -21,7 +21,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr decltype(auto) back_t::operator()(Xs&& xs) const {
@@ -48,6 +48,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::at_c<len - 1>(static_cast<Xs&&>(xs));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_BACK_HPP
diff --git a/boost/hana/basic_tuple.hpp b/boost/hana/basic_tuple.hpp
index c384c3a235f024c4375da5da87de1c62c6d32fbf..c8477c702058e520e20a8a2acf4d1be1c9c54ecb 100644
--- a/boost/hana/basic_tuple.hpp
+++ b/boost/hana/basic_tuple.hpp
@@ -32,7 +32,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace detail {
         //////////////////////////////////////////////////////////////////////
         // basic_tuple_impl<n, Xn>
@@ -259,6 +259,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::size_t<sizeof...(Xn)>{};
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_BASIC_TUPLE_HPP
diff --git a/boost/hana/bool.hpp b/boost/hana/bool.hpp
index 5774ccb78c4e1ea818187ba76a2fd88e671ce653..053532d921176380bf142814a1fe7c26a4c5b8d5 100644
--- a/boost/hana/bool.hpp
+++ b/boost/hana/bool.hpp
@@ -31,7 +31,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //////////////////////////////////////////////////////////////////////////
     // integral_constant
     //////////////////////////////////////////////////////////////////////////
@@ -266,6 +266,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         apply(hana::false_ const&, Then&&, Else&& e)
         { return static_cast<Else&&>(e); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_BOOL_HPP
diff --git a/boost/hana/cartesian_product.hpp b/boost/hana/cartesian_product.hpp
index 556c3b52372b391c92e2c89e74eb11f7ccc3e7c1..5ec263e91f6821c42340ff5244bcb011f4370b3f 100644
--- a/boost/hana/cartesian_product.hpp
+++ b/boost/hana/cartesian_product.hpp
@@ -26,7 +26,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr auto cartesian_product_t::operator()(Xs&& xs) const {
@@ -108,6 +108,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::make<S>();
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CARTESIAN_PRODUCT_HPP
diff --git a/boost/hana/chain.hpp b/boost/hana/chain.hpp
index ab889d186af2e4efbef538f81f8b1e3929b4f212..16993ccfb741e0d51011b9c7448744a4659a4bca 100644
--- a/boost/hana/chain.hpp
+++ b/boost/hana/chain.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/transform.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename F>
     constexpr decltype(auto) chain_t::operator()(Xs&& xs, F&& f) const {
@@ -45,6 +45,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                                  static_cast<F&&>(f)));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CHAIN_HPP
diff --git a/boost/hana/comparing.hpp b/boost/hana/comparing.hpp
index 4aaa546d4c8e3a89c6f4374df181dfa82f902c93..764c813c5d3c7175a2b7a1e3958fde042591cd3f 100644
--- a/boost/hana/comparing.hpp
+++ b/boost/hana/comparing.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/equal.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace detail {
         template <typename F>
         struct equal_by {
@@ -39,6 +39,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         return detail::equal_by<typename detail::decay<F>::type>{static_cast<F&&>(f)};
     }
     //! @endcond
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_COMPARING_HPP
diff --git a/boost/hana/concat.hpp b/boost/hana/concat.hpp
index 27f2ad0bf2064bd7a8dcdb8820fa1ffc0c9a1d5e..e32412883c63c6c1bd111ff5384894b0b0d2e4d9 100644
--- a/boost/hana/concat.hpp
+++ b/boost/hana/concat.hpp
@@ -25,7 +25,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Ys>
     constexpr auto concat_t::operator()(Xs&& xs, Ys&& ys) const {
@@ -75,6 +75,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                  std::make_index_sequence<yi>{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCAT_HPP
diff --git a/boost/hana/concept/applicative.hpp b/boost/hana/concept/applicative.hpp
index 84b92927eb18edf5981165b154d97d81e1d09f24..bba40d9982f704a8a7e19d3e42ebf5ce4068ec5c 100644
--- a/boost/hana/concept/applicative.hpp
+++ b/boost/hana/concept/applicative.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/lift.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename A>
     struct Applicative
         : hana::integral_constant<bool,
@@ -28,6 +28,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             !is_default<lift_impl<typename tag_of<A>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_APPLICATIVE_HPP
diff --git a/boost/hana/concept/comonad.hpp b/boost/hana/concept/comonad.hpp
index 6cf950590fba6526456fc6ce59b00407cd757621..b5eff93ba3ec83349fcc212c9070faf05f8a3e85 100644
--- a/boost/hana/concept/comonad.hpp
+++ b/boost/hana/concept/comonad.hpp
@@ -21,7 +21,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/extract.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename W>
     struct Comonad
         : hana::integral_constant<bool,
@@ -30,6 +30,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                  !is_default<extend_impl<typename tag_of<W>::type>>::value)
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_COMONAD_HPP
diff --git a/boost/hana/concept/comparable.hpp b/boost/hana/concept/comparable.hpp
index bcecfcd0abc4879909326450a83016d35b65e5fc..fcda6fb7b6bf20fa807c70c179287cf78ba9be94 100644
--- a/boost/hana/concept/comparable.hpp
+++ b/boost/hana/concept/comparable.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/equal.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename T>
     struct Comparable
         : hana::integral_constant<bool,
@@ -27,6 +27,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                    typename tag_of<T>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_COMPARABLE_HPP
diff --git a/boost/hana/concept/constant.hpp b/boost/hana/concept/constant.hpp
index 5e549ddf76dc05bdb4f67c3617543a67bb29bcb1..6abaf1ab5aceeb06ff3b27efa6907cdede6001a1 100644
--- a/boost/hana/concept/constant.hpp
+++ b/boost/hana/concept/constant.hpp
@@ -19,13 +19,13 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/value.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename C>
     struct Constant
         : hana::integral_constant<bool,
             !is_default<value_impl<typename tag_of<C>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_CONSTANT_HPP
diff --git a/boost/hana/concept/euclidean_ring.hpp b/boost/hana/concept/euclidean_ring.hpp
index e0de0477b08c8ad07da20f86801114903f5784e2..32d7125a8961042912fe33006c59752a496ece65 100644
--- a/boost/hana/concept/euclidean_ring.hpp
+++ b/boost/hana/concept/euclidean_ring.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/mod.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename R>
     struct EuclideanRing
         : hana::integral_constant<bool,
@@ -30,6 +30,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                  typename tag_of<R>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_EUCLIDEAN_RING_HPP
diff --git a/boost/hana/concept/foldable.hpp b/boost/hana/concept/foldable.hpp
index 6d88b58285aa51afe7ac9a9321d982688b49800d..49be73de0c04eae7e65baaab82c2aec9dd8f61a9 100644
--- a/boost/hana/concept/foldable.hpp
+++ b/boost/hana/concept/foldable.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/unpack.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename T>
     struct Foldable
         : hana::integral_constant<bool,
@@ -28,6 +28,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             !is_default<unpack_impl<typename tag_of<T>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_FOLDABLE_HPP
diff --git a/boost/hana/concept/functor.hpp b/boost/hana/concept/functor.hpp
index 4fe7428b32b1bd70ed9e9ab20c788281b176df94..a2cb0c2915e75edf0dabcbccc6f60a9bb2636778 100644
--- a/boost/hana/concept/functor.hpp
+++ b/boost/hana/concept/functor.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/transform.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename F>
     struct Functor
         : hana::integral_constant<bool,
@@ -28,6 +28,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             !is_default<adjust_if_impl<typename tag_of<F>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_FUNCTOR_HPP
diff --git a/boost/hana/concept/group.hpp b/boost/hana/concept/group.hpp
index 2b16728b4f161ddc14bf7cb282205b3f9d159ec5..187de179980725cb04d01830019691584ebcf3cb 100644
--- a/boost/hana/concept/group.hpp
+++ b/boost/hana/concept/group.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/negate.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename G>
     struct Group
         : hana::integral_constant<bool,
@@ -29,6 +29,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                    typename tag_of<G>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_GROUP_HPP
diff --git a/boost/hana/concept/hashable.hpp b/boost/hana/concept/hashable.hpp
index b5a0ca0febf96fda511af797a1dbb7322eb084c9..61434e02b05cbc72f03b72edf853e9f78e9b8e52 100644
--- a/boost/hana/concept/hashable.hpp
+++ b/boost/hana/concept/hashable.hpp
@@ -20,13 +20,13 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/hash.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename T>
     struct Hashable
         : hana::integral_constant<bool,
             !is_default<hash_impl<typename tag_of<T>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_HASHABLE_HPP
diff --git a/boost/hana/concept/integral_constant.hpp b/boost/hana/concept/integral_constant.hpp
index cfb761da9b4aa0d605b451e71eda6155e87bf9bc..8f970f7c4d44429ee5afb6a805b369964920e4f1 100644
--- a/boost/hana/concept/integral_constant.hpp
+++ b/boost/hana/concept/integral_constant.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/integral_constant.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace detail {
         template <typename C, typename Tag = typename tag_of<C>::type>
         struct integral_constant_dispatch
@@ -38,6 +38,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         : detail::integral_constant_dispatch<C>
     { };
     //! @endcond
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_INTEGRAL_CONSTANT_HPP
diff --git a/boost/hana/concept/iterable.hpp b/boost/hana/concept/iterable.hpp
index 2949f70b2b3876da5d17c8d90daa75957787e51a..5f77c28b023806c02e32cfb23920aef50efaeb6d 100644
--- a/boost/hana/concept/iterable.hpp
+++ b/boost/hana/concept/iterable.hpp
@@ -21,7 +21,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/is_empty.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename It>
     struct Iterable
         : hana::integral_constant<bool,
@@ -30,6 +30,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             !is_default<is_empty_impl<typename tag_of<It>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_ITERABLE_HPP
diff --git a/boost/hana/concept/logical.hpp b/boost/hana/concept/logical.hpp
index 69e307906504b0c3c363f2b8285b812e3002a045..37e3548d5ea281b45b42931c7ef60c6fa06d56d1 100644
--- a/boost/hana/concept/logical.hpp
+++ b/boost/hana/concept/logical.hpp
@@ -21,7 +21,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/while.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename L>
     struct Logical
         : hana::integral_constant<bool,
@@ -30,6 +30,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             !is_default<while_impl<typename tag_of<L>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_LOGICAL_HPP
diff --git a/boost/hana/concept/metafunction.hpp b/boost/hana/concept/metafunction.hpp
index 70a9b0092ac9deedcd93b563b8038ff82bf98a66..64908830c5cb376a0d200880c0879ab0f43d381a 100644
--- a/boost/hana/concept/metafunction.hpp
+++ b/boost/hana/concept/metafunction.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/integral_constant.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace detail {
         template <typename F, typename Tag = typename tag_of<F>::type>
         struct metafunction_dispatch
@@ -36,6 +36,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct Metafunction
         : detail::metafunction_dispatch<F>
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_METAFUNCTION_HPP
diff --git a/boost/hana/concept/monad.hpp b/boost/hana/concept/monad.hpp
index 85fa06f9c3b4a8f871e31a53d1bd1c20e09e91fd..902f589ccda7a7b46982779898728a656b4ddb6e 100644
--- a/boost/hana/concept/monad.hpp
+++ b/boost/hana/concept/monad.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/flatten.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename M>
     struct Monad
         : hana::integral_constant<bool,
@@ -28,6 +28,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             !is_default<chain_impl<typename tag_of<M>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_MONAD_HPP
diff --git a/boost/hana/concept/monad_plus.hpp b/boost/hana/concept/monad_plus.hpp
index e9f2f1bf0911a1c6d90f6a271dc718df77f4935e..b17dda76b9945b242e910df367a30f81b1358f1d 100644
--- a/boost/hana/concept/monad_plus.hpp
+++ b/boost/hana/concept/monad_plus.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/empty.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename M>
     struct MonadPlus
         : hana::integral_constant<bool,
@@ -28,6 +28,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             !is_default<empty_impl<typename tag_of<M>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_MONAD_PLUS_HPP
diff --git a/boost/hana/concept/monoid.hpp b/boost/hana/concept/monoid.hpp
index adda475a261b37c2e8eca93333ab110e623cfa9c..b376d9a17ec7b7e41f4858851e2760850f1bba2e 100644
--- a/boost/hana/concept/monoid.hpp
+++ b/boost/hana/concept/monoid.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/zero.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename M>
     struct Monoid
         : hana::integral_constant<bool,
@@ -29,6 +29,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                   typename tag_of<M>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_MONOID_HPP
diff --git a/boost/hana/concept/orderable.hpp b/boost/hana/concept/orderable.hpp
index dfa82655fcb45dcfe3c696bd0e1562bbf703b198..0821311ba172e081fbe2e0d5e54a2f3506860ce0 100644
--- a/boost/hana/concept/orderable.hpp
+++ b/boost/hana/concept/orderable.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/less.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename Ord>
     struct Orderable
         : hana::integral_constant<bool,
@@ -27,6 +27,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                   typename tag_of<Ord>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_ORDERABLE_HPP
diff --git a/boost/hana/concept/product.hpp b/boost/hana/concept/product.hpp
index b1292ba1563719c095c5af4a9611c63c87f57e5c..fe5c42ca986b37959687e6c4f4e49e6df23ffc65 100644
--- a/boost/hana/concept/product.hpp
+++ b/boost/hana/concept/product.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/second.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename P>
     struct Product
         : hana::integral_constant<bool,
@@ -28,6 +28,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             !is_default<second_impl<typename tag_of<P>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_PRODUCT_HPP
diff --git a/boost/hana/concept/ring.hpp b/boost/hana/concept/ring.hpp
index a9598e8fb30c89ab91895423c3bc902a41219718..fa89b380730a3d3771f493661f703c1fe1424ac1 100644
--- a/boost/hana/concept/ring.hpp
+++ b/boost/hana/concept/ring.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/one.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename R>
     struct Ring
         : hana::integral_constant<bool,
@@ -29,6 +29,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                   typename tag_of<R>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_RING_HPP
diff --git a/boost/hana/concept/searchable.hpp b/boost/hana/concept/searchable.hpp
index 65b161de73bf37efb4ffdb95f25c8d01b58bc4a7..0a3b89a950413e493ebafab1d32c3ce28f2b4983 100644
--- a/boost/hana/concept/searchable.hpp
+++ b/boost/hana/concept/searchable.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/find_if.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename S>
     struct Searchable
         : hana::integral_constant<bool,
@@ -28,6 +28,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             !is_default<find_if_impl<typename tag_of<S>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_SEARCHABLE_HPP
diff --git a/boost/hana/concept/sequence.hpp b/boost/hana/concept/sequence.hpp
index 83e4b42d3d2657c86e1cca68dd1e0409d42f0224..0bf2f15b60a9de5640e83e4468d9ffc5807235a7 100644
--- a/boost/hana/concept/sequence.hpp
+++ b/boost/hana/concept/sequence.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/integral_constant.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace detail {
         template <typename S, typename Tag = typename hana::tag_of<S>::type>
         struct sequence_dispatch
@@ -39,6 +39,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         : detail::sequence_dispatch<S>
     { };
     //! @endcond
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_SEQUENCE_HPP
diff --git a/boost/hana/concept/struct.hpp b/boost/hana/concept/struct.hpp
index 49ac53b59cfa387d5afac122179c6cef7669692c..acb382151e9ded44755135fac3ab213ecd496d02 100644
--- a/boost/hana/concept/struct.hpp
+++ b/boost/hana/concept/struct.hpp
@@ -19,13 +19,13 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/integral_constant.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename S>
     struct Struct
         : hana::integral_constant<bool,
             !is_default<accessors_impl<typename tag_of<S>::type>>::value
         >
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONCEPT_STRUCT_HPP
diff --git a/boost/hana/config.hpp b/boost/hana/config.hpp
index 6790e024f8af3d409517cc9ee6bb5ef1ce075f8d..87590a180e6acc83d6f2d566014fc4b8ff06cde9 100644
--- a/boost/hana/config.hpp
+++ b/boost/hana/config.hpp
@@ -104,12 +104,14 @@ Distributed under the Boost Software License, Version 1.0.
 #   define BOOST_HANA_CONSTEXPR_LAMBDA /* nothing */
 #endif
 
-//////////////////////////////////////////////////////////////////////////////
-// Namespace macros
-//////////////////////////////////////////////////////////////////////////////
-#define BOOST_HANA_NAMESPACE_BEGIN namespace boost { namespace hana {
-
-#define BOOST_HANA_NAMESPACE_END }}
+// `BOOST_HANA_INLINE_VARIABLE` expands to `inline` when C++17 inline variables
+// are supported, and to nothing otherwise. This allows marking global variables
+// defined in a header as `inline` to avoid potential ODR violations.
+#if defined(__cplusplus) && __cplusplus > 201402L
+#   define BOOST_HANA_INLINE_VARIABLE inline
+#else
+#   define BOOST_HANA_INLINE_VARIABLE /* nothing */
+#endif
 
 //////////////////////////////////////////////////////////////////////////////
 // Library features and options that can be tweaked by users
diff --git a/boost/hana/contains.hpp b/boost/hana/contains.hpp
index 5e18a388dca84c17e9ff828b9c02b1141056b7b1..7a9f0bb3518a34093d374487fb1302152c8a978a 100644
--- a/boost/hana/contains.hpp
+++ b/boost/hana/contains.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/equal.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Key>
     constexpr auto contains_t::operator()(Xs&& xs, Key&& key) const {
@@ -46,6 +46,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                     hana::equal.to(static_cast<X&&>(x)));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CONTAINS_HPP
diff --git a/boost/hana/core/common.hpp b/boost/hana/core/common.hpp
index c32de77feb5dcfd51d5e2ea64fec6e1f9e7dd0a9..f51c423f6202a34d1d2e3670243fdad778bc19e8 100644
--- a/boost/hana/core/common.hpp
+++ b/boost/hana/core/common.hpp
@@ -22,7 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //////////////////////////////////////////////////////////////////////////
     // common
     //////////////////////////////////////////////////////////////////////////
@@ -104,6 +104,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     >> {
         using type = typename common<A, typename B::value_type>::type;
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CORE_COMMON_HPP
diff --git a/boost/hana/core/default.hpp b/boost/hana/core/default.hpp
index 45c70503c10089fb809853f3871e90fbfdcb9ab4..bd90a4a1552d52a297ae12431a56b45f295b48c7 100644
--- a/boost/hana/core/default.hpp
+++ b/boost/hana/core/default.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename Method, typename>
     struct is_default : std::false_type { };
 
@@ -27,6 +27,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     )>
         : std::true_type
     { };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CORE_DEFAULT_HPP
diff --git a/boost/hana/core/is_a.hpp b/boost/hana/core/is_a.hpp
index 019476ff0a255fcb375d89bad738525a17edceb7..13f79376ab8a9bd28d9bf5a364d393e99ad54ff6 100644
--- a/boost/hana/core/is_a.hpp
+++ b/boost/hana/core/is_a.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //////////////////////////////////////////////////////////////////////////
     // is_a
     //////////////////////////////////////////////////////////////////////////
@@ -36,6 +36,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(T const&) const
         { return hana::is_a<DataType, T>; }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CORE_IS_A_HPP
diff --git a/boost/hana/core/make.hpp b/boost/hana/core/make.hpp
index 53608df3f56327a5e00b81704d2c3401cf9fc50c..791d5580b13764c3e564fee6e84c08554a4aa812 100644
--- a/boost/hana/core/make.hpp
+++ b/boost/hana/core/make.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Datatype, typename>
     struct make_impl : make_impl<Datatype, when<true>> { };
@@ -40,6 +40,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(X&& ...x)
         { return make_helper(int{}, static_cast<X&&>(x)...); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CORE_MAKE_HPP
diff --git a/boost/hana/core/tag_of.hpp b/boost/hana/core/tag_of.hpp
index 656e246702b353efc1075e38921e80abb1f17601..1125e89d223b93741559f66bdaabe3021c136192 100644
--- a/boost/hana/core/tag_of.hpp
+++ b/boost/hana/core/tag_of.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename T, typename>
     struct tag_of : tag_of<T, when<true>> { };
@@ -54,6 +54,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                            std::remove_const_t<std::remove_reference_t<T>>>
         { };
     }
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CORE_TAG_OF_HPP
diff --git a/boost/hana/core/to.hpp b/boost/hana/core/to.hpp
index 1b54115162a78afeac48d700cb0964c975417294..a0bddba0aafe7650178ca8e551726318c09e7ab2 100644
--- a/boost/hana/core/to.hpp
+++ b/boost/hana/core/to.hpp
@@ -27,7 +27,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //////////////////////////////////////////////////////////////////////////
     // to
     //////////////////////////////////////////////////////////////////////////
@@ -191,6 +191,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(Xs&& xs)
         { return hana::unpack(static_cast<Xs&&>(xs), hana::make<S>); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CORE_TO_HPP
diff --git a/boost/hana/count.hpp b/boost/hana/count.hpp
index b912c342db308f491f4ca38bbec105380e296140..c88cf225d0d6d376acd1531746273761df93b14e 100644
--- a/boost/hana/count.hpp
+++ b/boost/hana/count.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/equal.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Value>
     constexpr auto count_t::operator()(Xs&& xs, Value&& value) const {
@@ -45,6 +45,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                 hana::equal.to(static_cast<Value&&>(value)));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_COUNT_HPP
diff --git a/boost/hana/count_if.hpp b/boost/hana/count_if.hpp
index e9ea4bc9c8713422f0101d5587b9b70ec8538463..20741e67a8c36340413fd9bc00ac294088ef680a 100644
--- a/boost/hana/count_if.hpp
+++ b/boost/hana/count_if.hpp
@@ -25,7 +25,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred>
     constexpr auto count_if_t::operator()(Xs&& xs, Pred&& pred) const {
@@ -87,6 +87,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_COUNT_IF_HPP
diff --git a/boost/hana/cycle.hpp b/boost/hana/cycle.hpp
index c7b7a9ee322f883e5a99560f2f4f92810a2e41fc..2cf45619b3486b36d5c352fa856c8e8dbb836f8d 100644
--- a/boost/hana/cycle.hpp
+++ b/boost/hana/cycle.hpp
@@ -28,7 +28,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename N>
     constexpr auto cycle_t::operator()(Xs&& xs, N const& n) const {
@@ -122,6 +122,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                          std::make_index_sequence<n * len>{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_CYCLE_HPP
diff --git a/boost/hana/detail/algorithm.hpp b/boost/hana/detail/algorithm.hpp
index 1929847e7a88d083db8e90651885c0daea8bc2cf..15c1a487680ef4980e7754c6d60b3bee7730c629 100644
--- a/boost/hana/detail/algorithm.hpp
+++ b/boost/hana/detail/algorithm.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     // Do not call this swap, otherwise it can get picked up by ADL and conflict
     // with std::swap (see https://github.com/boostorg/hana/issues/297).
     template <typename T>
@@ -181,6 +181,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
                 smallest = first;
         return smallest;
     }
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_ALGORITHM_HPP
diff --git a/boost/hana/detail/any_of.hpp b/boost/hana/detail/any_of.hpp
index de6b1c6ad2a1082c34882f67e67352c2f651335e..01c72b0da16df1062b31f179531ff7f63f999a84 100644
--- a/boost/hana/detail/any_of.hpp
+++ b/boost/hana/detail/any_of.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     std::false_type expand(...);
 
     template <template <typename ...> class Predicate, typename ...T>
@@ -41,6 +41,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
     struct any_of
         : decltype(any_of_impl<Predicate, T...>(int{}))
     { };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_ANY_OF_HPP
diff --git a/boost/hana/detail/array.hpp b/boost/hana/detail/array.hpp
index 8b2c276f5eb6b5c4f2ef737cf134fc483cc8a9f1..88742c87e94e0342d52eb0426fa1aaf2a28454b3 100644
--- a/boost/hana/detail/array.hpp
+++ b/boost/hana/detail/array.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename N>
     constexpr N factorial(N n) {
         N result = 1;
@@ -100,6 +100,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
         return M < N || detail::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
     }
 
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_ARRAY_HPP
diff --git a/boost/hana/detail/canonical_constant.hpp b/boost/hana/detail/canonical_constant.hpp
index 07d636fa17dde8cd172e3f9bf4ded692c2efd3e4..ac76ab333c0d7bc5fcf066ffe092f0c10769148a 100644
--- a/boost/hana/detail/canonical_constant.hpp
+++ b/boost/hana/detail/canonical_constant.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     //! @ingroup group-details
     //! Tag representing a canonical `Constant`.
     //!
@@ -26,7 +26,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
     struct CanonicalConstant {
         using value_type = T;
     };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 
 #include <boost/hana/concept/constant.hpp>
@@ -37,7 +37,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //////////////////////////////////////////////////////////////////////////
     // Constant
     //////////////////////////////////////////////////////////////////////////
@@ -75,6 +75,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct IntegralConstant<detail::CanonicalConstant<T>> {
         static constexpr bool value = std::is_integral<T>::value;
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_CANONICAL_CONSTANT_HPP
diff --git a/boost/hana/detail/concepts.hpp b/boost/hana/detail/concepts.hpp
index d7b48bc5ecac2bfedaefe04294dacfdc575aa72e..55f9d99994c426f7c057208a07372617a282ce02 100644
--- a/boost/hana/detail/concepts.hpp
+++ b/boost/hana/detail/concepts.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     //! @cond
     //////////////////////////////////////////////////////////////////////////
     // EqualityComparable
@@ -73,6 +73,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
         >
     { };
     //! @endcond
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_CONCEPTS_HPP
diff --git a/boost/hana/detail/create.hpp b/boost/hana/detail/create.hpp
index 354e5590ca4650a987b28917d130077ce73aa6bc..fa65f63b9abb29ccf139bb6e8573a6cb9737e034 100644
--- a/boost/hana/detail/create.hpp
+++ b/boost/hana/detail/create.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/decay.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     //! @ingroup group-details
     //! Implementation of the generic `std::make_xxx` pattern for arbitrary
     //! `xxx`s.
@@ -28,6 +28,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
             };
         }
     };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_CREATE_HPP
diff --git a/boost/hana/detail/decay.hpp b/boost/hana/detail/decay.hpp
index 7d8affa0b2adc50ffc617e544fbfd00b52bab0d3..02068496a9195200bfba6ac327115238d902a9c2 100644
--- a/boost/hana/detail/decay.hpp
+++ b/boost/hana/detail/decay.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     //! @ingroup group-details
     //! Equivalent to `std::decay`, except faster.
     //!
@@ -43,6 +43,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
     struct decay<T, R(A...)> { using type = R(*)(A...); };
     template <typename T, typename R, typename ...A>
     struct decay<T, R(A..., ...)> { using type = R(*)(A..., ...); };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_DECAY_HPP
diff --git a/boost/hana/detail/dispatch_if.hpp b/boost/hana/detail/dispatch_if.hpp
index 6e95f588785976934c246b6976591e03cd05e4aa..4f129c8786b7c167526379d62ee461403a59d5d9 100644
--- a/boost/hana/detail/dispatch_if.hpp
+++ b/boost/hana/detail/dispatch_if.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     struct deleted_implementation {
         template <typename ...T>
         static constexpr auto apply(T&& ...) = delete;
@@ -51,6 +51,6 @@ BOOST_HANA_NAMESPACE_BEGIN
 #else
     #define BOOST_HANA_DISPATCH_IF(IMPL, ...) IMPL
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_DISPATCH_IF_HPP
diff --git a/boost/hana/detail/ebo.hpp b/boost/hana/detail/ebo.hpp
index 01ca009ce2dc9e16da426adea063a32506d4ae29..b637797e762a9955a7e01648b6687acfebb4e2ee 100644
--- a/boost/hana/detail/ebo.hpp
+++ b/boost/hana/detail/ebo.hpp
@@ -105,11 +105,11 @@ namespace _hana {
     { return static_cast<V&&>(x.data_); }
 } // end namespace _hana
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace detail {
         using ::_hana::ebo;
         using ::_hana::ebo_get;
     }
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_EBO_HPP
diff --git a/boost/hana/detail/fast_and.hpp b/boost/hana/detail/fast_and.hpp
index a43e3e9c455fcfd5e9e6d2c7a96097815d0409af..fc04b7e93e460fa0423e0b6c708ebd19daf8f078 100644
--- a/boost/hana/detail/fast_and.hpp
+++ b/boost/hana/detail/fast_and.hpp
@@ -15,11 +15,11 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <bool ...b>
     struct fast_and
         : std::is_same<fast_and<b...>, fast_and<(b, true)...>>
     { };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_FAST_AND_HPP
diff --git a/boost/hana/detail/first_unsatisfied_index.hpp b/boost/hana/detail/first_unsatisfied_index.hpp
index e42cc598e55225115a73aa39c2bfc771a4404597..1a7b316530dfdb6e6fdddc18f9d4f9b07bdb99a4 100644
--- a/boost/hana/detail/first_unsatisfied_index.hpp
+++ b/boost/hana/detail/first_unsatisfied_index.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <bool, typename Pred, typename ...Xs>
     struct find_tail_size;
 
@@ -51,6 +51,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
             >;
         }
     };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_FIRST_UNSATISFIED_INDEX_HPP
diff --git a/boost/hana/detail/has_common_embedding.hpp b/boost/hana/detail/has_common_embedding.hpp
index ffaf6908b87ccc0ba7118d642bc2675caa0c480b..a714fbd8f81c851eecc4701f73ca07b1b5460404 100644
--- a/boost/hana/detail/has_common_embedding.hpp
+++ b/boost/hana/detail/has_common_embedding.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <template <typename...> class Concept, typename T, typename U, typename = void>
     struct has_common_embedding_impl : std::false_type { };
 
@@ -64,6 +64,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
     template <template <typename...> class Concept, typename T, typename U>
     using has_nontrivial_common_embedding =
         typename has_nontrivial_common_embedding_impl<Concept, T, U>::type;
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_HAS_COMMON_EMBEDDING_HPP
diff --git a/boost/hana/detail/has_duplicates.hpp b/boost/hana/detail/has_duplicates.hpp
index ff9f080482ebc165851d5e445c68a32b15911b05..d16d5cf8ecc734409bfc4e25e140e3cdc9292082 100644
--- a/boost/hana/detail/has_duplicates.hpp
+++ b/boost/hana/detail/has_duplicates.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename T, typename ...U>
     constexpr std::size_t pack_count() {
         std::size_t c = 0;
@@ -60,6 +60,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
             !detail::fast_and<(detail::pack_count<T, T...>() == 1)...>::value
         ;
     };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_HAS_DUPLICATES_HPP
diff --git a/boost/hana/detail/hash_table.hpp b/boost/hana/detail/hash_table.hpp
index 19a85dd7643f9f74d1f662b114caf5d8899914a3..72d76bd78e1808816ac1bc66321ed81ea027c42c 100644
--- a/boost/hana/detail/hash_table.hpp
+++ b/boost/hana/detail/hash_table.hpp
@@ -27,7 +27,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename Hash, std::size_t ...i>
     struct bucket { };
 
@@ -140,6 +140,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
             bucket<typename decltype(hana::hash(std::declval<KeyAtIndex<i>>()))::type, i>...
         >;
     };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_HASH_TABLE_HPP
diff --git a/boost/hana/detail/index_if.hpp b/boost/hana/detail/index_if.hpp
index f643eb76ff29584617d7be91bbf7ccb9889afa49..d38c2c19331d12db501404f2ddd0c2d108b006fa 100644
--- a/boost/hana/detail/index_if.hpp
+++ b/boost/hana/detail/index_if.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <std::size_t i, std::size_t N, bool Done>
     struct index_if_helper;
 
@@ -50,6 +50,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
         using type = typename index_if_helper<0, sizeof...(Xs), false>
             ::template f<Pred, Xs...>;
     };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_INDEX_IF_HPP
diff --git a/boost/hana/detail/integral_constant.hpp b/boost/hana/detail/integral_constant.hpp
index 72a40dacaef1f6050a07788c9ee09eb08d6166aa..6f5f986422af990d9e564c2e75e9e4d7ec0197a9 100644
--- a/boost/hana/detail/integral_constant.hpp
+++ b/boost/hana/detail/integral_constant.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Tag representing `hana::integral_constant`.
     //! @relates hana::integral_constant
     template <typename T>
@@ -244,6 +244,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         using hana_tag = integral_constant_tag<T>;
     };
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_INTEGRAL_CONSTANT_HPP
diff --git a/boost/hana/detail/nested_by.hpp b/boost/hana/detail/nested_by.hpp
index 6bdfe70c431bf85982a1e9fb418816ea78f5a0f0..dd06c143435ec73893a92b2c52e79dd6c8ae6543 100644
--- a/boost/hana/detail/nested_by.hpp
+++ b/boost/hana/detail/nested_by.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/partial.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     //! @cond
     template <typename Algorithm>
     template <typename Predicate, typename Object>
@@ -35,6 +35,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
                              static_cast<Predicate&&>(predicate));
     }
     //! @endcond
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_NESTED_BY_HPP
diff --git a/boost/hana/detail/nested_by_fwd.hpp b/boost/hana/detail/nested_by_fwd.hpp
index 4e82f64cd6e5ee68f75359bb67d7ed9b9152e0f1..25250b4323051ea8d22b12d57d6006bac80e4d94 100644
--- a/boost/hana/detail/nested_by_fwd.hpp
+++ b/boost/hana/detail/nested_by_fwd.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename Algorithm>
     struct nested_by_t {
         template <typename Predicate, typename Object>
@@ -50,6 +50,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
 
     template <typename Algorithm>
     constexpr nested_by_t<Algorithm> nested_by<Algorithm>::by;
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_NESTED_BY_FWD_HPP
diff --git a/boost/hana/detail/nested_than.hpp b/boost/hana/detail/nested_than.hpp
index d4a7c5ffc65489ffc96e694f047dd8b1529a847e..b138908829e65e8aaca9ee0b1713d1c564cc5d84 100644
--- a/boost/hana/detail/nested_than.hpp
+++ b/boost/hana/detail/nested_than.hpp
@@ -17,13 +17,13 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/partial.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     //! @cond
     template <typename Algorithm>
     template <typename X>
     constexpr decltype(auto) nested_than_t<Algorithm>::operator()(X&& x) const
     { return hana::partial(hana::flip(Algorithm{}), static_cast<X&&>(x)); }
     //! @endcond
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_NESTED_THAN_HPP
diff --git a/boost/hana/detail/nested_than_fwd.hpp b/boost/hana/detail/nested_than_fwd.hpp
index 39231050f3947c16806b0ea0c3c27c7e6ed33d19..8b5819a51f7315765a8575e63d8d2b3883bc2bb0 100644
--- a/boost/hana/detail/nested_than_fwd.hpp
+++ b/boost/hana/detail/nested_than_fwd.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename Algorithm>
     struct nested_than_t {
         template <typename X>
@@ -42,6 +42,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
 
     template <typename Algorithm>
     constexpr nested_than_t<Algorithm> nested_than<Algorithm>::than;
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_NESTED_THAN_FWD_HPP
diff --git a/boost/hana/detail/nested_to.hpp b/boost/hana/detail/nested_to.hpp
index 2f6154d36726a127c7f4933aea22720724541567..e5d513ac8e951cb464d12f83e4241be5df785ad0 100644
--- a/boost/hana/detail/nested_to.hpp
+++ b/boost/hana/detail/nested_to.hpp
@@ -16,13 +16,13 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/partial.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     //! @cond
     template <typename Algorithm>
     template <typename X>
     constexpr decltype(auto) nested_to_t<Algorithm>::operator()(X&& x) const
     { return hana::partial(Algorithm{}, static_cast<X&&>(x)); }
     //! @endcond
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_NESTED_TO_HPP
diff --git a/boost/hana/detail/nested_to_fwd.hpp b/boost/hana/detail/nested_to_fwd.hpp
index ec3161136c9f142f709348cdd58fb2b25871a501..e34f77ccd2bc02a78b5175847d0e400b399b1327 100644
--- a/boost/hana/detail/nested_to_fwd.hpp
+++ b/boost/hana/detail/nested_to_fwd.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename Algorithm>
     struct nested_to_t {
         template <typename X>
@@ -42,6 +42,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
 
     template <typename Algorithm>
     constexpr nested_to_t<Algorithm> nested_to<Algorithm>::to;
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_NESTED_TO_FWD_HPP
diff --git a/boost/hana/detail/operators/adl.hpp b/boost/hana/detail/operators/adl.hpp
index 59a81600b658ebc8a4383ce331a2b97e160add5b..403517b60fa720fe7a1fe4076edfe144890c6489 100644
--- a/boost/hana/detail/operators/adl.hpp
+++ b/boost/hana/detail/operators/adl.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace operators {
+namespace boost { namespace hana { namespace detail { namespace operators {
     //! @ingroup group-details
     //! Enables [ADL](http://en.cppreference.com/w/cpp/language/adl) in the
     //! `hana::detail::operators` namespace.
@@ -29,6 +29,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace operators {
     //! is not a concern, `adl<>` can simply be used.
     template <typename ...>
     struct adl { };
-}} BOOST_HANA_NAMESPACE_END
+}} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_OPERATORS_ADL_HPP
diff --git a/boost/hana/detail/operators/arithmetic.hpp b/boost/hana/detail/operators/arithmetic.hpp
index 58f432db78bd29acaec9ade4a397fc66077ca9af..2ee4f5ff25c304dd4cb6cdaba324d432f817ec92 100644
--- a/boost/hana/detail/operators/arithmetic.hpp
+++ b/boost/hana/detail/operators/arithmetic.hpp
@@ -22,7 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename Tag>
     struct arithmetic_operators {
         static constexpr bool value = false;
@@ -73,6 +73,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
         constexpr auto operator%(X&& x, Y&& y)
         { return hana::mod(static_cast<X&&>(x), static_cast<Y&&>(y)); }
     } // end namespace operators
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_OPERATORS_ARITHMETIC_HPP
diff --git a/boost/hana/detail/operators/comparable.hpp b/boost/hana/detail/operators/comparable.hpp
index 762c2dadfad97e53883b979bec1010357e6e4bfe..5150a5b7eed5002aa216b58e24ef670c413d0d8b 100644
--- a/boost/hana/detail/operators/comparable.hpp
+++ b/boost/hana/detail/operators/comparable.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename Tag>
     struct comparable_operators {
         static constexpr bool value = false;
@@ -47,6 +47,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
         constexpr auto operator!=(X&& x, Y&& y)
         { return hana::not_equal(static_cast<X&&>(x), static_cast<Y&&>(y)); }
     } // end namespace operators
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_OPERATORS_COMPARABLE_HPP
diff --git a/boost/hana/detail/operators/iterable.hpp b/boost/hana/detail/operators/iterable.hpp
index 6dcb6bc25e9062802b46f03a577ff6124829ff21..a9c2b8d9c14d0808022c3ff63cf8e458d3ac5aed 100644
--- a/boost/hana/detail/operators/iterable.hpp
+++ b/boost/hana/detail/operators/iterable.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/at.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename Derived>
     struct iterable_operators {
         template <typename N>
@@ -35,6 +35,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
                             static_cast<N&&>(n));
         }
     };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_OPERATORS_ITERABLE_HPP
diff --git a/boost/hana/detail/operators/logical.hpp b/boost/hana/detail/operators/logical.hpp
index 4645ca2bb40ea6ba6cf797d0ec85ca2075d6d22e..8aa969ce78bd3c2ce8ede33890c43dc543161404 100644
--- a/boost/hana/detail/operators/logical.hpp
+++ b/boost/hana/detail/operators/logical.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename Tag>
     struct logical_operators {
         static constexpr bool value = false;
@@ -46,6 +46,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
         constexpr auto operator!(X&& x)
         { return hana::not_(static_cast<X&&>(x)); }
     } // end namespace operators
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_OPERATORS_LOGICAL_HPP
diff --git a/boost/hana/detail/operators/monad.hpp b/boost/hana/detail/operators/monad.hpp
index ccc421c56a07b9eaefed0e87cb56f6b27ec603de..88a1d65d0cf3e5d3ba4e8a58401b87fb559477e4 100644
--- a/boost/hana/detail/operators/monad.hpp
+++ b/boost/hana/detail/operators/monad.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename Tag>
     struct monad_operators {
         static constexpr bool value = false;
@@ -30,6 +30,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
         constexpr auto operator|(Xs&& xs, F&& f)
         { return hana::chain(static_cast<Xs&&>(xs), static_cast<F&&>(f)); }
     } // end namespace operators
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_OPERATORS_MONAD_HPP
diff --git a/boost/hana/detail/operators/orderable.hpp b/boost/hana/detail/operators/orderable.hpp
index cf46829a046e98a8fa1833e7bdf6f42a68e8d92d..bb883d68f774ea9205c6fd9dde370eeee906bf24 100644
--- a/boost/hana/detail/operators/orderable.hpp
+++ b/boost/hana/detail/operators/orderable.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename Tag>
     struct orderable_operators {
         static constexpr bool value = false;
@@ -55,6 +55,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
         constexpr auto operator>=(X&& x, Y&& y)
         { return hana::greater_equal(static_cast<X&&>(x), static_cast<Y&&>(y)); }
     } // end namespace operators
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_OPERATORS_ORDERABLE_HPP
diff --git a/boost/hana/detail/operators/searchable.hpp b/boost/hana/detail/operators/searchable.hpp
index 69d67465daca4ba4d612b5012657a731e1e69968..001478238b8de16661c2c1052d57f38e35c979b3 100644
--- a/boost/hana/detail/operators/searchable.hpp
+++ b/boost/hana/detail/operators/searchable.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/at_key.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename Derived>
     struct searchable_operators {
         template <typename Key>
@@ -35,6 +35,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
                                 static_cast<Key&&>(key));
         }
     };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_OPERATORS_SEARCHABLE_HPP
diff --git a/boost/hana/detail/std_common_type.hpp b/boost/hana/detail/std_common_type.hpp
index b5fe6f318e8610c88e94ba3ef243666d5ec073f9..0d36f87d1b61700393cf9fa68c05b99f93abefad 100644
--- a/boost/hana/detail/std_common_type.hpp
+++ b/boost/hana/detail/std_common_type.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     //! @ingroup group-details
     //! Equivalent to `std::common_type`, except it is SFINAE-friendly and
     //! does not support custom specializations.
@@ -31,6 +31,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
             decltype(true ? std::declval<T>() : std::declval<U>())
         >::type;
     };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_STD_COMMON_TYPE_HPP
diff --git a/boost/hana/detail/struct_macros.hpp b/boost/hana/detail/struct_macros.hpp
index 8298de67d67a886f74f58c3f5e1daf9a3461bb28..b6119d04c905f42c7f495014b4d7d083588554ce 100644
--- a/boost/hana/detail/struct_macros.hpp
+++ b/boost/hana/detail/struct_macros.hpp
@@ -32,7 +32,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace struct_detail {
+namespace boost { namespace hana { namespace struct_detail {
     template <typename Memptr, Memptr ptr>
     struct member_ptr {
         template <typename T>
@@ -57,7 +57,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace struct_detail {
         constexpr std::size_t len = strlen(hana::at_c<n>(Names::get()));
         return prepare_member_name_impl<n, Names>(std::make_index_sequence<len>{});
     }
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 //////////////////////////////////////////////////////////////////////////////
 // BOOST_HANA_PP_NARG
diff --git a/boost/hana/detail/struct_macros.hpp.erb b/boost/hana/detail/struct_macros.hpp.erb
index ecfd0edd6982df122b97bbee7888b811532e591a..b4b254dc23d64610b226fe0e7810d889b2acb473 100644
--- a/boost/hana/detail/struct_macros.hpp.erb
+++ b/boost/hana/detail/struct_macros.hpp.erb
@@ -51,7 +51,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace struct_detail {
+namespace boost { namespace hana { namespace struct_detail {
     template <typename Memptr, Memptr ptr>
     struct member_ptr {
         template <typename T>
@@ -76,7 +76,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace struct_detail {
         constexpr std::size_t len = strlen(hana::at_c<n>(Names::get()));
         return prepare_member_name_impl<n, Names>(std::make_index_sequence<len>{});
     }
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 //////////////////////////////////////////////////////////////////////////////
 // BOOST_HANA_PP_NARG
diff --git a/boost/hana/detail/type_at.hpp b/boost/hana/detail/type_at.hpp
index c7b8311f47804760393af6c77aa409de99373496..25efd5154304d9b3f518abddab52352e2e5d2d37 100644
--- a/boost/hana/detail/type_at.hpp
+++ b/boost/hana/detail/type_at.hpp
@@ -23,7 +23,7 @@ Distributed under the Boost Software License, Version 1.0.
 #   endif
 #endif
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     namespace td {
         template <std::size_t I, typename T>
         struct elt { using type = T; };
@@ -52,6 +52,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
         using type = typename decltype(td::get_elt<n>(Indexer{}))::type;
 #endif
     };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_TYPE_AT_HPP
diff --git a/boost/hana/detail/type_foldl1.hpp b/boost/hana/detail/type_foldl1.hpp
index b65e3463feb7bf4ee20d78ccc5ed5f9dd3ce2203..2c5aa64c69d021f968b3a329efd225e32c80cdaa 100644
--- a/boost/hana/detail/type_foldl1.hpp
+++ b/boost/hana/detail/type_foldl1.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <unsigned n>
     struct type_foldl1_t;
 
@@ -140,6 +140,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
         using type = typename type_foldl1_t<(sizeof...(xn) > 6 ? 6 : sizeof...(xn))>
                      ::template result<f, x1, xn...>;
     };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_TYPE_FOLDL1_HPP
diff --git a/boost/hana/detail/type_foldr1.hpp b/boost/hana/detail/type_foldr1.hpp
index badf1b03d688321d9ca8012bb0afe5be767342b1..bd94c63f848a332cb5f4d25b4428e3dd4d901b8d 100644
--- a/boost/hana/detail/type_foldr1.hpp
+++ b/boost/hana/detail/type_foldr1.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <unsigned n>
     struct type_foldr1_t;
 
@@ -144,6 +144,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
         using type = typename type_foldr1_t<(sizeof...(xn) > 6 ? 6 : sizeof...(xn))>
                      ::template result<f, x1, xn...>;
     };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_TYPE_FOLDR1_HPP
diff --git a/boost/hana/detail/unpack_flatten.hpp b/boost/hana/detail/unpack_flatten.hpp
index 65cb3d9507a17d7d34f922cb7e8b147b910e08eb..23666e08cab32ed587963301b2f5d66149a57228 100644
--- a/boost/hana/detail/unpack_flatten.hpp
+++ b/boost/hana/detail/unpack_flatten.hpp
@@ -21,7 +21,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <std::size_t ...Lengths>
     struct flatten_indices {
         // avoid empty arrays by appending 0 to `lengths`
@@ -65,6 +65,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
         return Indices::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f),
                         std::make_index_sequence<Indices::flat_length>{});
     }
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_UNPACK_FLATTEN_HPP
diff --git a/boost/hana/detail/variadic/at.hpp b/boost/hana/detail/variadic/at.hpp
index 9ef9e2944dc7d93767078e7e45ed3fb4f0ad40bc..6fff65d3ebe61ea4310e3968de8e6ed91f59dfdd 100644
--- a/boost/hana/detail/variadic/at.hpp
+++ b/boost/hana/detail/variadic/at.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
+namespace boost { namespace hana { namespace detail { namespace variadic {
     template <std::size_t n, typename = std::make_index_sequence<n>>
     struct at_type;
 
@@ -34,7 +34,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
     };
 
     template <std::size_t n>
-    constexpr at_type<n> at{};
-}} BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr at_type<n> at{};
+}} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_VARIADIC_AT_HPP
diff --git a/boost/hana/detail/variadic/drop_into.hpp b/boost/hana/detail/variadic/drop_into.hpp
index b31d1e98d54b5aa95b319249744b8d436a48929a..1932bfc9239bf268c6a3dcb9c1b741184f5371f8 100644
--- a/boost/hana/detail/variadic/drop_into.hpp
+++ b/boost/hana/detail/variadic/drop_into.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
+namespace boost { namespace hana { namespace detail { namespace variadic {
     template <std::size_t n, typename F, typename = std::make_index_sequence<n>>
     struct dropper;
 
@@ -41,7 +41,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
     };
 
     template <std::size_t n>
-    constexpr make_dropper<n> drop_into{};
-}} BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr make_dropper<n> drop_into{};
+}} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_VARIADIC_DROP_INTO_HPP
diff --git a/boost/hana/detail/variadic/foldl1.hpp b/boost/hana/detail/variadic/foldl1.hpp
index 31388028ab014780ce79b94d7c8046661e2a373f..3c68817e9ed166c2ea809529d6429ce6ca54fe9d 100644
--- a/boost/hana/detail/variadic/foldl1.hpp
+++ b/boost/hana/detail/variadic/foldl1.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
+namespace boost { namespace hana { namespace detail { namespace variadic {
     //! @cond
     template <unsigned int n, typename = when<true>>
     struct foldl1_impl;
@@ -207,8 +207,8 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
         }
     };
 
-    constexpr foldl1_t foldl1{};
-    constexpr auto foldl = foldl1;
-}} BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr foldl1_t foldl1{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto foldl = foldl1;
+}} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_VARIADIC_FOLDL1_HPP
diff --git a/boost/hana/detail/variadic/foldr1.hpp b/boost/hana/detail/variadic/foldr1.hpp
index c7323cdaf86ab825de25a03170f22514eaf25869..f5eb5e484c5902d6a1cc07c38b0806074ea4961e 100644
--- a/boost/hana/detail/variadic/foldr1.hpp
+++ b/boost/hana/detail/variadic/foldr1.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
+namespace boost { namespace hana { namespace detail { namespace variadic {
     //! @cond
     template <unsigned int n, typename = when<true>>
     struct foldr1_impl;
@@ -193,7 +193,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
         }
     };
 
-    constexpr foldr1_t foldr1{};
+    BOOST_HANA_INLINE_VARIABLE constexpr foldr1_t foldr1{};
 
     struct foldr_t {
         template <typename F, typename State, typename ...Xn>
@@ -204,7 +204,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
         }
     };
 
-    constexpr foldr_t foldr{};
-}} BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr foldr_t foldr{};
+}} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_VARIADIC_FOLDR1_HPP
diff --git a/boost/hana/detail/variadic/reverse_apply.hpp b/boost/hana/detail/variadic/reverse_apply.hpp
index a1f71ff53cb66c33ad5776c4211e120ffd0b350e..1a221d859456b4136d74eb529d94159348692dcf 100644
--- a/boost/hana/detail/variadic/reverse_apply.hpp
+++ b/boost/hana/detail/variadic/reverse_apply.hpp
@@ -14,14 +14,14 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/variadic/reverse_apply/unrolled.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
-    BOOST_HANA_CONSTEXPR_LAMBDA auto reverse_apply =
+namespace boost { namespace hana { namespace detail { namespace variadic {
+    BOOST_HANA_INLINE_VARIABLE BOOST_HANA_CONSTEXPR_LAMBDA auto reverse_apply =
         [](auto&& f, auto&& ...x) -> decltype(auto) {
             return detail::variadic::reverse_apply_unrolled(
                 static_cast<decltype(f)>(f),
                 static_cast<decltype(x)>(x)...
             );
         };
-}} BOOST_HANA_NAMESPACE_END
+}} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_HPP
diff --git a/boost/hana/detail/variadic/reverse_apply/flat.hpp b/boost/hana/detail/variadic/reverse_apply/flat.hpp
index 09bc818e6b35879c505e6e5172850c9b9c312f63..a9c3eab4f5782b3693f1ab7768af867cca82f546 100644
--- a/boost/hana/detail/variadic/reverse_apply/flat.hpp
+++ b/boost/hana/detail/variadic/reverse_apply/flat.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
+namespace boost { namespace hana { namespace detail { namespace variadic {
     template <int ...i, typename F, typename ...X>
     constexpr decltype(auto)
     reverse_apply_flat_helper(std::integer_sequence<int, i...>, F&& f, X&& ...x)
@@ -36,6 +36,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
             static_cast<X&&>(x)...
         );
     }
-}} BOOST_HANA_NAMESPACE_END
+}} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_FLAT_HPP
diff --git a/boost/hana/detail/variadic/reverse_apply/unrolled.hpp b/boost/hana/detail/variadic/reverse_apply/unrolled.hpp
index e6bf3d0c55e3686dd3e540f8213690eb3f03266f..7628efe1825bd334437f883b40bf0c71b5ccc0e1 100644
--- a/boost/hana/detail/variadic/reverse_apply/unrolled.hpp
+++ b/boost/hana/detail/variadic/reverse_apply/unrolled.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/reverse_partial.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
+namespace boost { namespace hana { namespace detail { namespace variadic {
     struct reverse_apply_unrolled_impl {
         template <typename F>
         constexpr decltype(auto) operator()(F&& f) const {
@@ -80,8 +80,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
         }
     };
 
-    constexpr reverse_apply_unrolled_impl reverse_apply_unrolled{};
-
-}} BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr reverse_apply_unrolled_impl reverse_apply_unrolled{};
+}} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_UNROLLED_HPP
diff --git a/boost/hana/detail/variadic/split_at.hpp b/boost/hana/detail/variadic/split_at.hpp
index c068c1bcb959feb7d92c91961f6738d44b338e94..443a1868a339a8b1ecdd24692ce22c5c81990574 100644
--- a/boost/hana/detail/variadic/split_at.hpp
+++ b/boost/hana/detail/variadic/split_at.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
+namespace boost { namespace hana { namespace detail { namespace variadic {
     template <std::size_t n>
     struct split_at_t {
         template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename ...Xs>
@@ -147,7 +147,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
     };
 
     template <std::size_t n>
-    constexpr _makesplit_at_t<n> split_at{};
-}} BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr _makesplit_at_t<n> split_at{};
+}} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_VARIADIC_SPLIT_AT_HPP
diff --git a/boost/hana/detail/variadic/take.hpp b/boost/hana/detail/variadic/take.hpp
index 4d97a5b85392c8ef8ebe5d05ae9ee36ebf1eb9a8..a9e46e19e4fc81bc7275e18a2f0ae863a7ae1cc9 100644
--- a/boost/hana/detail/variadic/take.hpp
+++ b/boost/hana/detail/variadic/take.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
+namespace boost { namespace hana { namespace detail { namespace variadic {
     struct take_impl2 {
         template <typename F, typename ...Xs>
         constexpr decltype(auto) operator()(F&& f, Xs&& ...xs) const {
@@ -45,7 +45,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic {
     };
 
     template <std::size_t n>
-    constexpr take_t<n> take{};
-}} BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr take_t<n> take{};
+}} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_VARIADIC_TAKE_HPP
diff --git a/boost/hana/detail/void_t.hpp b/boost/hana/detail/void_t.hpp
index 9eedd11441e5e7d4eea3daeadfd047d545326d7d..c64f520e06d98ade00899ad18275d56d232633ed 100644
--- a/boost/hana/detail/void_t.hpp
+++ b/boost/hana/detail/void_t.hpp
@@ -13,9 +13,9 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     template <typename ...>
     using void_t = void;
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_VOID_T_HPP
diff --git a/boost/hana/detail/wrong.hpp b/boost/hana/detail/wrong.hpp
index ce5544fcdfe42161b98ff19a95bd5c18ad7c295d..d3da3093c422b2f8fc8e39acc2d37a1dabcc80b7 100644
--- a/boost/hana/detail/wrong.hpp
+++ b/boost/hana/detail/wrong.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace detail {
+namespace boost { namespace hana { namespace detail {
     //! @ingroup group-detail
     //! Equivalent to a type-dependent `std::false_type`.
     //!
@@ -28,6 +28,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
     //! @include example/detail/wrong.cpp
     template <typename ...>
     struct wrong : std::false_type { };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DETAIL_WRONG_HPP
diff --git a/boost/hana/difference.hpp b/boost/hana/difference.hpp
index d2e2897d6e610c89bb26e5da7a1e45dfb7cf927e..7c08a03365a8d8aa30f34635db791354cb721e08 100644
--- a/boost/hana/difference.hpp
+++ b/boost/hana/difference.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/erase_key.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Ys>
     constexpr auto difference_t::operator()(Xs&& xs, Ys&& ys) const {
@@ -35,6 +35,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         template <typename ...Args>
         static constexpr auto apply(Args&& ...) = delete;
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DIFFERENCE_HPP
diff --git a/boost/hana/div.hpp b/boost/hana/div.hpp
index 5b75ef10bec57072b4f549a043daf1d2c5b5e6f4..3eac969eb8ad7d1b898c84ed9e745488d81cf05e 100644
--- a/boost/hana/div.hpp
+++ b/boost/hana/div.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr decltype(auto) div_t::operator()(X&& x, Y&& y) const {
@@ -102,6 +102,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(X const&, Y const&)
         { return hana::to<C>(detail::constant_from_div<C, X, Y>{}); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DIV_HPP
diff --git a/boost/hana/drop_back.hpp b/boost/hana/drop_back.hpp
index 0e5837584a5ed0e61331da06fdc8312d16446ea5..44d1793cd5912a5298c050224c5fc76546a11506 100644
--- a/boost/hana/drop_back.hpp
+++ b/boost/hana/drop_back.hpp
@@ -25,7 +25,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename N>
     constexpr auto drop_back_t::operator()(Xs&& xs, N const& n) const {
@@ -70,6 +70,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                     std::make_index_sequence<(n > len ? 0 : len - n)>{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DROP_BACK_HPP
diff --git a/boost/hana/drop_front.hpp b/boost/hana/drop_front.hpp
index 2fa5ade1084104274fb13e44fd1cda03c6b232c5..1bb74c2a1cb26b7be76ac9afdd7ab4bbe9bdbe15 100644
--- a/boost/hana/drop_front.hpp
+++ b/boost/hana/drop_front.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/integral_constant.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename N>
     constexpr auto drop_front_t::operator()(Xs&& xs, N const& n) const {
@@ -52,6 +52,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         template <typename Xs, typename N>
         static constexpr auto apply(Xs&&, N const&) = delete;
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DROP_FRONT_HPP
diff --git a/boost/hana/drop_front_exactly.hpp b/boost/hana/drop_front_exactly.hpp
index a6af69115d04b71a3a4c016d4411547aebacca0e..7a311f3c2aa81712904e16563771d8d534fc73d0 100644
--- a/boost/hana/drop_front_exactly.hpp
+++ b/boost/hana/drop_front_exactly.hpp
@@ -22,7 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/is_empty.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename N>
     constexpr auto drop_front_exactly_t::operator()(Xs&& xs, N const& n) const {
@@ -80,6 +80,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return result; // NRVO applied
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DROP_FRONT_EXACTLY_HPP
diff --git a/boost/hana/drop_while.hpp b/boost/hana/drop_while.hpp
index b1f921b1d8697e0bc333844cb8e019a4f085621b..a7c23c922e0dd24a37e8e89e074c0882adc7f66d 100644
--- a/boost/hana/drop_while.hpp
+++ b/boost/hana/drop_while.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/lazy.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred>
     constexpr auto drop_while_t::operator()(Xs&& xs, Pred&& pred) const {
@@ -88,6 +88,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                     FirstUnsatisfied{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DROP_WHILE_HPP
diff --git a/boost/hana/duplicate.hpp b/boost/hana/duplicate.hpp
index 783ae05fa051b213ff26935dbcdc9f79c971036f..777ef4ea8a383f192d6b8b2db6ef84ee8aaef50b 100644
--- a/boost/hana/duplicate.hpp
+++ b/boost/hana/duplicate.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/id.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename W_>
     constexpr decltype(auto) duplicate_t::operator()(W_&& w) const {
@@ -43,6 +43,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(X&& x)
         { return hana::extend(static_cast<X&&>(x), hana::id); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_DUPLICATE_HPP
diff --git a/boost/hana/empty.hpp b/boost/hana/empty.hpp
index 86b81f408cc2076405d617b1b024ee4db093a1dc..e7b0ec8b49cc613b41007ef2af6c1ebb69318c85 100644
--- a/boost/hana/empty.hpp
+++ b/boost/hana/empty.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/make.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename M>
     constexpr auto empty_t<M>::operator()() const {
@@ -48,6 +48,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::make<S>();
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EMPTY_HPP
diff --git a/boost/hana/equal.hpp b/boost/hana/equal.hpp
index dd09b7eeecfa22e7b932ae3945c1a7d2cad0d110..ff6da957cb13e3527dedaf01f892d632e93e8693 100644
--- a/boost/hana/equal.hpp
+++ b/boost/hana/equal.hpp
@@ -40,7 +40,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr auto equal_t::operator()(X&& x, Y&& y) const {
@@ -201,6 +201,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                 detail::compare_struct_members<X, Y>{x, y});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EQUAL_HPP
diff --git a/boost/hana/erase_key.hpp b/boost/hana/erase_key.hpp
index 4a059c959846c9ddf2b72f45ae24879cb0e68dbf..990239981a9fafff3afcb243d5c40a0542144b6b 100644
--- a/boost/hana/erase_key.hpp
+++ b/boost/hana/erase_key.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/dispatch.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Set, typename ...Args>
     constexpr decltype(auto) erase_key_t::operator()(Set&& set, Args&& ...args) const {
@@ -32,6 +32,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         template <typename ...Args>
         static constexpr auto apply(Args&& ...) = delete;
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ERASE_KEY_HPP
diff --git a/boost/hana/eval.hpp b/boost/hana/eval.hpp
index 1d8f4aa75850a5d81e4ac3d548fc020cc0e926c1..bc83cd5f7c7badabe786f9f0ab06d5cf5f0da01c 100644
--- a/boost/hana/eval.hpp
+++ b/boost/hana/eval.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/id.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Expr>
     constexpr decltype(auto) eval_t::operator()(Expr&& expr) const {
@@ -52,6 +52,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(Expr&& expr)
         { return eval_helper(static_cast<Expr&&>(expr), int{}); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EVAL_HPP
diff --git a/boost/hana/eval_if.hpp b/boost/hana/eval_if.hpp
index 7d0be870d389eed272b9caab7542322ffb6a855c..087488ffaa3f516cd71b23940add09f86c037723 100644
--- a/boost/hana/eval_if.hpp
+++ b/boost/hana/eval_if.hpp
@@ -23,7 +23,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Cond, typename Then, typename Else>
     constexpr decltype(auto) eval_if_t::operator()(Cond&& cond, Then&& then_, Else&& else_) const {
@@ -88,6 +88,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                   static_cast<Else&&>(e));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EVAL_IF_HPP
diff --git a/boost/hana/experimental/printable.hpp b/boost/hana/experimental/printable.hpp
index 637ebe69274668e8b6d368948f3f58b67bf35b07..ee44a146e9f02d191deeec48e63027d058344a0c 100644
--- a/boost/hana/experimental/printable.hpp
+++ b/boost/hana/experimental/printable.hpp
@@ -40,7 +40,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace experimental {
+namespace boost { namespace hana { namespace experimental {
     template <typename T>
     struct Printable;
 
@@ -87,7 +87,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace experimental {
         }
     };
 
-    constexpr print_t print{};
+    BOOST_HANA_INLINE_VARIABLE constexpr print_t print{};
 #endif
 
     // Define the `Printable` concept
@@ -252,6 +252,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace experimental {
             return "type<" + boost::core::demangle(typeid(Type).name()) + '>';
         }
     };
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXPERIMENTAL_PRINTABLE_HPP
diff --git a/boost/hana/experimental/type_name.hpp b/boost/hana/experimental/type_name.hpp
index f3db176178662b685e32af87fd734c88b69e50a2..78e1285e0384a699900b478a2fd5bb9d4d5756af 100644
--- a/boost/hana/experimental/type_name.hpp
+++ b/boost/hana/experimental/type_name.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace experimental {
+namespace boost { namespace hana { namespace experimental {
     namespace detail {
         struct cstring {
             char const* ptr;
@@ -59,6 +59,6 @@ BOOST_HANA_NAMESPACE_BEGIN namespace experimental {
         constexpr auto name = detail::type_name_impl2<T>();
         return detail::type_name_impl1<T>(std::make_index_sequence<name.length>{});
     }
-} BOOST_HANA_NAMESPACE_END
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXPERIMENTAL_TYPE_NAME_HPP
diff --git a/boost/hana/experimental/types.hpp b/boost/hana/experimental/types.hpp
index be1436a5068b227a39f80c224a3e6d98886ec049..79667bf37f55a5ace14a8ddef6efcb2c470c8c29 100644
--- a/boost/hana/experimental/types.hpp
+++ b/boost/hana/experimental/types.hpp
@@ -29,7 +29,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace experimental {
         //! @ingroup group-experimental
         //! Container optimized for holding types.
@@ -153,6 +153,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr hana::false_ apply(Ts const&, Us const&)
         { return {}; }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXPERIMENTAL_TYPES_HPP
diff --git a/boost/hana/experimental/view.hpp b/boost/hana/experimental/view.hpp
index cc2f4c606fd921184ff560dd2d9906022fc727eb..1ca2584237e2d5d0ad1c7d8494471a9804f1a211 100644
--- a/boost/hana/experimental/view.hpp
+++ b/boost/hana/experimental/view.hpp
@@ -56,7 +56,7 @@ Distributed under the Boost Software License, Version 1.0.
 //       "view" is not cheap to copy, which is inconsistent with the usual
 //       expectations about views.
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
 
 namespace experimental {
     struct view_tag;
@@ -148,7 +148,7 @@ namespace experimental {
             return {s1, s2};
         }
     };
-    constexpr make_joined_view_t joined{};
+    BOOST_HANA_INLINE_VARIABLE constexpr make_joined_view_t joined{};
 
     namespace detail {
         template <typename Sequence1, typename Sequence2>
@@ -510,6 +510,6 @@ struct less_impl<S, experimental::view_tag, hana::when<hana::Sequence<S>::value>
     }
 };
 
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXPERIMENTAL_VIEW_HPP
diff --git a/boost/hana/ext/boost/fusion/deque.hpp b/boost/hana/ext/boost/fusion/deque.hpp
index 698638157df945b01e2cfc745a918e2d3d85f235..b4856d8eefa478df8f1acdb15f4cef546cd42263 100644
--- a/boost/hana/ext/boost/fusion/deque.hpp
+++ b/boost/hana/ext/boost/fusion/deque.hpp
@@ -48,7 +48,7 @@ namespace boost { namespace fusion {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace boost { namespace fusion {
         struct deque_tag;
     }}}
@@ -103,6 +103,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return ::boost::fusion::make_deque(static_cast<Xs&&>(xs)...);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_BOOST_FUSION_DEQUE_HPP
diff --git a/boost/hana/ext/boost/fusion/detail/common.hpp b/boost/hana/ext/boost/fusion/detail/common.hpp
index 298d74d93d89bb192546731f50aca9ac289adc19..871484844595e7c0532195fdb9e933afb03521b9 100644
--- a/boost/hana/ext/boost/fusion/detail/common.hpp
+++ b/boost/hana/ext/boost/fusion/detail/common.hpp
@@ -26,7 +26,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace detail {
         template <typename T>
         struct is_fusion_sequence {
@@ -74,6 +74,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct Sequence<S, when<detail::is_fusion_sequence<S>::value>> {
         static constexpr bool value = true;
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_BOOST_FUSION_DETAIL_COMMON_HPP
diff --git a/boost/hana/ext/boost/fusion/list.hpp b/boost/hana/ext/boost/fusion/list.hpp
index 0bdcb23dc5e8e002133ba28a1f9336170c3d3339..0460c2b600e83bb4c2db442ba85c5091be61e6e3 100644
--- a/boost/hana/ext/boost/fusion/list.hpp
+++ b/boost/hana/ext/boost/fusion/list.hpp
@@ -51,7 +51,7 @@ namespace boost { namespace fusion {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace boost { namespace fusion {
         struct list_tag;
     }}}
@@ -106,6 +106,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return ::boost::fusion::make_list(static_cast<Xs&&>(xs)...);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_BOOST_FUSION_LIST_HPP
diff --git a/boost/hana/ext/boost/fusion/tuple.hpp b/boost/hana/ext/boost/fusion/tuple.hpp
index cf427e51d30abea4ce661a43e83114d2fc1d2594..95c7f5543d4be64b5ffa11f78cbe8f1a96688739 100644
--- a/boost/hana/ext/boost/fusion/tuple.hpp
+++ b/boost/hana/ext/boost/fusion/tuple.hpp
@@ -38,12 +38,12 @@ namespace boost { namespace fusion {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace boost { namespace fusion {
         // In the current version of Boost.Fusion, `boost::fusion::tuple` is
         // basically an alias to `boost::fusion::vector`, hence the alias.
         using tuple_tag = vector_tag;
     }}}
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_BOOST_FUSION_TUPLE_HPP
diff --git a/boost/hana/ext/boost/fusion/vector.hpp b/boost/hana/ext/boost/fusion/vector.hpp
index 9a2a3a8c5d75c6281a7a182736bc1c8179dc1bdf..52b92e2ae34c335093f63973da05954a035bd412 100644
--- a/boost/hana/ext/boost/fusion/vector.hpp
+++ b/boost/hana/ext/boost/fusion/vector.hpp
@@ -50,7 +50,7 @@ namespace boost { namespace fusion {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace boost { namespace fusion {
         struct vector_tag;
     }}}
@@ -105,6 +105,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return ::boost::fusion::make_vector(static_cast<Xs&&>(xs)...);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_BOOST_FUSION_VECTOR_HPP
diff --git a/boost/hana/ext/boost/mpl/integral_c.hpp b/boost/hana/ext/boost/mpl/integral_c.hpp
index 68ddd184869bf7fe79a9ecf85747f878f88b0f8f..15ad681a4836ab4466577d60d873d35796be7c51 100644
--- a/boost/hana/ext/boost/mpl/integral_c.hpp
+++ b/boost/hana/ext/boost/mpl/integral_c.hpp
@@ -41,7 +41,7 @@ namespace boost { namespace mpl {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace boost { namespace mpl {
         template <typename T>
         struct integral_c_tag { using value_type = T; };
@@ -76,6 +76,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return ::boost::mpl::integral_c<T, N::value>{};
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_BOOST_MPL_INTEGRAL_C_HPP
diff --git a/boost/hana/ext/boost/mpl/list.hpp b/boost/hana/ext/boost/mpl/list.hpp
index 677b9a85bf2f4656506d5dbb5b54017cbeaf486f..7893a3ae22b5f704bb0df3a49c811ec7cc18f65e 100644
--- a/boost/hana/ext/boost/mpl/list.hpp
+++ b/boost/hana/ext/boost/mpl/list.hpp
@@ -94,7 +94,7 @@ namespace boost { namespace mpl {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace boost { namespace mpl {
         using list_tag = ::boost::mpl::sequence_tag< ::boost::mpl::list<>>::type;
     }}}
@@ -181,6 +181,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return typename decltype(list_type)::type{};
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_BOOST_MPL_LIST_HPP
diff --git a/boost/hana/ext/boost/mpl/vector.hpp b/boost/hana/ext/boost/mpl/vector.hpp
index 706c2dd06da66d1f2cec0aea2ebf0bad498d65ba..21448483788c1526610384a8a435d94748c6a51c 100644
--- a/boost/hana/ext/boost/mpl/vector.hpp
+++ b/boost/hana/ext/boost/mpl/vector.hpp
@@ -94,7 +94,7 @@ namespace boost { namespace mpl {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace boost { namespace mpl {
         using vector_tag = ::boost::mpl::sequence_tag< ::boost::mpl::vector<>>::type;
     }}}
@@ -196,6 +196,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return typename decltype(vector_type)::type{};
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_BOOST_MPL_VECTOR_HPP
diff --git a/boost/hana/ext/boost/tuple.hpp b/boost/hana/ext/boost/tuple.hpp
index 581c973bda4b817dd31b50f3ff7a0a6bebc3ccf0..96fed34eea1ccdf72a024356e578854f8689a7a8 100644
--- a/boost/hana/ext/boost/tuple.hpp
+++ b/boost/hana/ext/boost/tuple.hpp
@@ -47,7 +47,7 @@ namespace boost {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace boost { struct tuple_tag; }}
 
     template <typename ...Xs>
@@ -133,6 +133,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             >{static_cast<Xs&&>(xs)...};
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_BOOST_TUPLE_HPP
diff --git a/boost/hana/ext/std/array.hpp b/boost/hana/ext/std/array.hpp
index 59bc49cf8d1e54e29f3d6bfb658e4e15a9266e59..2abf8de40679f976c70fb7dd2f331d33aa3a77c5 100644
--- a/boost/hana/ext/std/array.hpp
+++ b/boost/hana/ext/std/array.hpp
@@ -66,7 +66,7 @@ namespace std {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace std { struct array_tag; }}
 
     template <typename T, std::size_t N>
@@ -166,6 +166,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             }
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_STD_ARRAY_HPP
diff --git a/boost/hana/ext/std/integer_sequence.hpp b/boost/hana/ext/std/integer_sequence.hpp
index 83536a31022072723a179a202e4f8dcc5afa11ab..bf976f5ee9bebcff1d32f19835834e0f8a216655 100644
--- a/boost/hana/ext/std/integer_sequence.hpp
+++ b/boost/hana/ext/std/integer_sequence.hpp
@@ -62,7 +62,7 @@ namespace std {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace std { struct integer_sequence_tag; }}
 
     template <typename T, T ...v>
@@ -135,6 +135,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr auto apply(std::integer_sequence<T, xs...> const&)
         { return hana::bool_c<sizeof...(xs) == 0>; }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_STD_INTEGER_SEQUENCE_HPP
diff --git a/boost/hana/ext/std/integral_constant.hpp b/boost/hana/ext/std/integral_constant.hpp
index f949a6648176caf85ad5cc9216d20059aa121422..8b4512b2460a69117ed23f21a6e0b8d2955ee3ac 100644
--- a/boost/hana/ext/std/integral_constant.hpp
+++ b/boost/hana/ext/std/integral_constant.hpp
@@ -39,7 +39,7 @@ namespace std {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace std {
         template <typename T>
         struct integral_constant_tag { using value_type = T; };
@@ -91,6 +91,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return std::integral_constant<T, N::value>{};
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_STD_INTEGRAL_CONSTANT_HPP
diff --git a/boost/hana/ext/std/pair.hpp b/boost/hana/ext/std/pair.hpp
index a2f429a6420484e129c80b800f3daa089b73f504..a1a370f01afde9db818f065e255e06e4f6e96637 100644
--- a/boost/hana/ext/std/pair.hpp
+++ b/boost/hana/ext/std/pair.hpp
@@ -37,7 +37,7 @@ namespace std {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace std { struct pair_tag; }}
 
     template <typename First, typename Second>
@@ -86,6 +86,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr U&& apply(std::pair<T, U>&& p)
         {  return static_cast<U&&>(p.second); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_STD_PAIR_HPP
diff --git a/boost/hana/ext/std/ratio.hpp b/boost/hana/ext/std/ratio.hpp
index bf25632f7d467e744969cb6b1b817ab6d621892e..4c6d138b1cac0ca739ceca9e089ee8088db5a0b9 100644
--- a/boost/hana/ext/std/ratio.hpp
+++ b/boost/hana/ext/std/ratio.hpp
@@ -60,7 +60,7 @@ namespace std {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace std { struct ratio_tag; }}
 
     template <std::intmax_t num, std::intmax_t den>
@@ -159,6 +159,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr std::ratio<0> apply(R1 const&, R2 const&)
         { return {}; }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_STD_RATIO_HPP
diff --git a/boost/hana/ext/std/tuple.hpp b/boost/hana/ext/std/tuple.hpp
index 112eb6147543a0d25dcaf62dff9e6d74ef00c957..030db417e3934d8977238d3273e48bc60c7e3bd1 100644
--- a/boost/hana/ext/std/tuple.hpp
+++ b/boost/hana/ext/std/tuple.hpp
@@ -51,7 +51,7 @@ namespace std {
 #endif
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace std { struct tuple_tag; }}
 
     template <typename ...Xs>
@@ -175,6 +175,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct Sequence<ext::std::tuple_tag> {
         static constexpr bool value = true;
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_STD_TUPLE_HPP
diff --git a/boost/hana/ext/std/vector.hpp b/boost/hana/ext/std/vector.hpp
index d286d8f9a80c62d4fd2d2a110b84cf0a1ff589c9..86bb3d7f82eef9f8e60b3bb491babba53dc12bde 100644
--- a/boost/hana/ext/std/vector.hpp
+++ b/boost/hana/ext/std/vector.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <vector>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace ext { namespace std { struct vector_tag; }}
 
     template <typename T, typename Allocator>
@@ -105,6 +105,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     };
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXT_STD_VECTOR_HPP
diff --git a/boost/hana/extend.hpp b/boost/hana/extend.hpp
index 466e74e7777ffa4181e2e8a28c0a0515ef801bf4..2d823ba831e774043986e9c8f506504176fa0bb9 100644
--- a/boost/hana/extend.hpp
+++ b/boost/hana/extend.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/transform.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename W_, typename F>
     constexpr decltype(auto) extend_t::operator()(W_&& w, F&& f) const {
@@ -45,6 +45,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                    static_cast<F&&>(f));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXTEND_HPP
diff --git a/boost/hana/extract.hpp b/boost/hana/extract.hpp
index a9cd58624c6d7bdfa730453cedf64e95de7ab0a3..fd6727aeb527cf442a119c5878fb61885cacc8ff 100644
--- a/boost/hana/extract.hpp
+++ b/boost/hana/extract.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/dispatch.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename W_>
     constexpr decltype(auto) extract_t::operator()(W_&& w) const {
@@ -40,6 +40,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         template <typename ...Args>
         static constexpr auto apply(Args&& ...args) = delete;
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_EXTRACT_HPP
diff --git a/boost/hana/fill.hpp b/boost/hana/fill.hpp
index de82ac9b8e1220edc3c6bbdb461ad2e4a44d79dd..f83f2dc633f53270deb005346251e7bb4e9f61b5 100644
--- a/boost/hana/fill.hpp
+++ b/boost/hana/fill.hpp
@@ -22,7 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/unpack.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Value>
     constexpr auto fill_t::operator()(Xs&& xs, Value&& value) const {
@@ -69,6 +69,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::unpack(xs, filler<V>{v});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FILL_HPP
diff --git a/boost/hana/filter.hpp b/boost/hana/filter.hpp
index e8f7d5142817c0b7c77dc4a654d4b104ab2a0b80..4189be19a23f53c0366bb56e620dac5ac426dcb2 100644
--- a/boost/hana/filter.hpp
+++ b/boost/hana/filter.hpp
@@ -31,7 +31,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred>
     constexpr auto filter_t::operator()(Xs&& xs, Pred&& pred) const {
@@ -130,6 +130,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FILTER_HPP
diff --git a/boost/hana/find.hpp b/boost/hana/find.hpp
index 4ebc48a2b5d75e330b2008b9551db9b6eeed13ba..3c121ab119df06ea53ab79f2b33a65943b406275 100644
--- a/boost/hana/find.hpp
+++ b/boost/hana/find.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/find_if.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Key>
     constexpr auto find_t::operator()(Xs&& xs, Key const& key) const {
@@ -56,6 +56,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                  detail::equal_to<Key>{key});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FIND_HPP
diff --git a/boost/hana/find_if.hpp b/boost/hana/find_if.hpp
index de9c3d3eeacdeb4fc90a97c569b3a4f2c6148e06..f8307ae7b92261e51f834c545e54e38612a5bf67 100644
--- a/boost/hana/find_if.hpp
+++ b/boost/hana/find_if.hpp
@@ -31,7 +31,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred>
     constexpr auto find_if_t::operator()(Xs&& xs, Pred&& pred) const {
@@ -124,6 +124,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FIND_IF_HPP
diff --git a/boost/hana/first.hpp b/boost/hana/first.hpp
index f364b2242f99790260ea9bb2bd0e2ac532a7aeac..d771ed07c24e6803f266883a6f2b6b02d4a996f1 100644
--- a/boost/hana/first.hpp
+++ b/boost/hana/first.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/dispatch.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Pair>
     constexpr decltype(auto) first_t::operator()(Pair&& pair) const {
@@ -40,6 +40,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         template <typename ...Args>
         static constexpr auto apply(Args&& ...) = delete;
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FIRST_HPP
diff --git a/boost/hana/flatten.hpp b/boost/hana/flatten.hpp
index 6c5ccc99c3db498c80ec3dc101c960f6c4fefa79..1ea8dfd84309cb1fdfe44f0e2e2fb5f8cd35757d 100644
--- a/boost/hana/flatten.hpp
+++ b/boost/hana/flatten.hpp
@@ -25,7 +25,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr auto flatten_t::operator()(Xs&& xs) const {
@@ -57,6 +57,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return detail::unpack_flatten(static_cast<Xs&&>(xs), hana::make<S>);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FLATTEN_HPP
diff --git a/boost/hana/fold_left.hpp b/boost/hana/fold_left.hpp
index fc51b84d70fc680220dbc353d7fd4ffe5f1480e9..cb485b6fd09ac5bed74afd51de3166abdc57f1fd 100644
--- a/boost/hana/fold_left.hpp
+++ b/boost/hana/fold_left.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/unpack.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename State, typename F>
     constexpr decltype(auto) fold_left_t::operator()(Xs&& xs, State&& state, F&& f) const {
@@ -92,6 +92,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FOLD_LEFT_HPP
diff --git a/boost/hana/fold_right.hpp b/boost/hana/fold_right.hpp
index 73bdc6f88d57356d584ccde51e1faee6a3b4510b..c2130e6fc09ef9ba66c6aa226804ac3fbd286653 100644
--- a/boost/hana/fold_right.hpp
+++ b/boost/hana/fold_right.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/unpack.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename State, typename F>
     constexpr decltype(auto) fold_right_t::operator()(Xs&& xs, State&& state, F&& f) const {
@@ -92,6 +92,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FOLD_RIGHT_HPP
diff --git a/boost/hana/for_each.hpp b/boost/hana/for_each.hpp
index defc1de4adf4e91b1f445a08f912619cfc89f68a..34fdabeb693e147921b921f06508ec17b8254d36 100644
--- a/boost/hana/for_each.hpp
+++ b/boost/hana/for_each.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/unpack.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename F>
     constexpr void for_each_t::operator()(Xs&& xs, F&& f) const {
@@ -57,6 +57,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                          detail::on_each<decltype(&f)>{&f});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FOR_EACH_HPP
diff --git a/boost/hana/front.hpp b/boost/hana/front.hpp
index 96d7651a66c99f95f3dd95987bc7975eb00e5079..6589f5ed3eb6778e2628be9349e237baebbc6bc3 100644
--- a/boost/hana/front.hpp
+++ b/boost/hana/front.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/dispatch.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr decltype(auto) front_t::operator()(Xs&& xs) const {
@@ -42,6 +42,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(Xs&& xs)
         { return hana::at_c<0>(static_cast<Xs&&>(xs)); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FRONT_HPP
diff --git a/boost/hana/functional/always.hpp b/boost/hana/functional/always.hpp
index df41b851e7bddefdf1ba2c592dab3963bae6498e..74cbc2bd9ca70bcfadb2f283d90de122b5da2053 100644
--- a/boost/hana/functional/always.hpp
+++ b/boost/hana/functional/always.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Return a constant function returning `x` regardless of the
     //! argument(s) it is invoked with.
@@ -57,8 +57,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         { return std::move(val_); }
     };
 
-    constexpr detail::create<_always> always{};
+    BOOST_HANA_INLINE_VARIABLE constexpr detail::create<_always> always{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_ALWAYS_HPP
diff --git a/boost/hana/functional/apply.hpp b/boost/hana/functional/apply.hpp
index d705767e19ae90d2f84f185a8052e0f9516e7470..e036e31d7837c68fbcceb6502ab7a6c95b0e9ff4 100644
--- a/boost/hana/functional/apply.hpp
+++ b/boost/hana/functional/apply.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Invokes a Callable with the given arguments.
     //!
@@ -78,8 +78,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     };
 
-    constexpr apply_t apply{};
+    BOOST_HANA_INLINE_VARIABLE constexpr apply_t apply{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_APPLY_HPP
diff --git a/boost/hana/functional/arg.hpp b/boost/hana/functional/arg.hpp
index 5dd5658effe272e1038b1290681ef4e7546321b4..1bbfa58b2b624a78a19439b41a93824e44a2de87 100644
--- a/boost/hana/functional/arg.hpp
+++ b/boost/hana/functional/arg.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Return the `n`th passed argument.
     //!
@@ -134,8 +134,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <std::size_t n>
-    constexpr arg_t<n> arg{};
+    BOOST_HANA_INLINE_VARIABLE constexpr arg_t<n> arg{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_ARG_HPP
diff --git a/boost/hana/functional/capture.hpp b/boost/hana/functional/capture.hpp
index 65b467583389e6f8cabda8da36dd03d060e35c16..aaa6555f4234c30d6ae53a901f5148bf0297ff88 100644
--- a/boost/hana/functional/capture.hpp
+++ b/boost/hana/functional/capture.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Create a function capturing the given variables.
     //!
@@ -105,8 +105,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     };
 
-    constexpr make_capture_t capture{};
+    BOOST_HANA_INLINE_VARIABLE constexpr make_capture_t capture{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_CAPTURE_HPP
diff --git a/boost/hana/functional/compose.hpp b/boost/hana/functional/compose.hpp
index bbc53f6ff4f669f66547f4b6fd621ac82a065d75..07cea3da489ab4f897a16ba40f59a391b731f0b8 100644
--- a/boost/hana/functional/compose.hpp
+++ b/boost/hana/functional/compose.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Return the composition of two functions or more.
     //!
@@ -101,8 +101,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     };
 
-    constexpr _make_compose compose{};
+    BOOST_HANA_INLINE_VARIABLE constexpr _make_compose compose{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_COMPOSE_HPP
diff --git a/boost/hana/functional/curry.hpp b/boost/hana/functional/curry.hpp
index 762718c2084a10e5ae91f35e40ee5cc8ed29a819..f80e4e621027846c1993a81dcb7a6e65af1fb706 100644
--- a/boost/hana/functional/curry.hpp
+++ b/boost/hana/functional/curry.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Curry a function up to the given number of arguments.
     //!
@@ -109,7 +109,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <std::size_t n>
-    constexpr make_curry_t<n> curry{};
+    BOOST_HANA_INLINE_VARIABLE constexpr make_curry_t<n> curry{};
 
     namespace curry_detail { namespace {
         template <std::size_t n>
@@ -165,6 +165,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         { return std::move(f)(); }
     };
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_CURRY_HPP
diff --git a/boost/hana/functional/demux.hpp b/boost/hana/functional/demux.hpp
index f76b68ed48d5adb3dc62d4ee8e60bd5e0b0a6bd2..9854ec631a03f9f5b3146eaad8281b871fd77267 100644
--- a/boost/hana/functional/demux.hpp
+++ b/boost/hana/functional/demux.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Invoke a function with the results of invoking other functions
     //! on its arguments.
@@ -262,8 +262,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     };
 
-    constexpr make_pre_demux_t demux{};
+    BOOST_HANA_INLINE_VARIABLE constexpr make_pre_demux_t demux{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_DEMUX_HPP
diff --git a/boost/hana/functional/fix.hpp b/boost/hana/functional/fix.hpp
index 4c636ee10b2e8f374cb8bfc1dd70f1a2a0bbf416..5a1ac34a8f418b1e76fe9a4e32c8d96e827ae4db 100644
--- a/boost/hana/functional/fix.hpp
+++ b/boost/hana/functional/fix.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Return a function computing the fixed point of a function.
     //!
@@ -59,7 +59,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     template <typename F>
     struct fix_t;
 
-    constexpr detail::create<fix_t> fix{};
+    BOOST_HANA_INLINE_VARIABLE constexpr detail::create<fix_t> fix{};
 
     template <typename F>
     struct fix_t {
@@ -78,6 +78,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         { return std::move(f)(fix(f), static_cast<X&&>(x)...); }
     };
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_FIX_HPP
diff --git a/boost/hana/functional/flip.hpp b/boost/hana/functional/flip.hpp
index d896f5e8d31da7411d39ec61235ef7efcc25b805..540ef76e1b4d5fab05a10b7c07f628cecc91601c 100644
--- a/boost/hana/functional/flip.hpp
+++ b/boost/hana/functional/flip.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Invoke a function with its two first arguments reversed.
     //!
@@ -66,8 +66,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     };
 
-    constexpr detail::create<flip_t> flip{};
+    BOOST_HANA_INLINE_VARIABLE constexpr detail::create<flip_t> flip{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_FLIP_HPP
diff --git a/boost/hana/functional/id.hpp b/boost/hana/functional/id.hpp
index 04c9443b94dc887262d954765299707a124dfcea..3f13b06cbb886c7b320112fe7c7c74a4f8a8f181 100644
--- a/boost/hana/functional/id.hpp
+++ b/boost/hana/functional/id.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! The identity function -- returns its argument unchanged.
     //!
@@ -31,8 +31,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     };
 
-    constexpr id_t id{};
+    BOOST_HANA_INLINE_VARIABLE constexpr id_t id{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_ID_HPP
diff --git a/boost/hana/functional/infix.hpp b/boost/hana/functional/infix.hpp
index 7b5d82cbe0ba45d1ccd96c024cd7be83d86075ed..c673a1bea93d1bdd8a15b8b5de38e915fa2116d8 100644
--- a/boost/hana/functional/infix.hpp
+++ b/boost/hana/functional/infix.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Return an equivalent function that can also be applied in infix
     //! notation.
@@ -178,8 +178,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     } // end namespace infix_detail
 
-    constexpr infix_detail::make_infix<false, false> infix{};
+    BOOST_HANA_INLINE_VARIABLE constexpr infix_detail::make_infix<false, false> infix{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_INFIX_HPP
diff --git a/boost/hana/functional/iterate.hpp b/boost/hana/functional/iterate.hpp
index 9a4ce3e9b22751e6b0f1ebea28395d91accf82f4..f7209885f3153e9478e77c74eeb63ddd297d040b 100644
--- a/boost/hana/functional/iterate.hpp
+++ b/boost/hana/functional/iterate.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Applies another function `n` times to its argument.
     //!
@@ -194,8 +194,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <std::size_t n>
-    constexpr make_iterate_t<n> iterate{};
+    BOOST_HANA_INLINE_VARIABLE constexpr make_iterate_t<n> iterate{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_ITERATE_HPP
diff --git a/boost/hana/functional/lockstep.hpp b/boost/hana/functional/lockstep.hpp
index 2f607818838ca6dc8d1ca0802f61b23c4f1c131f..a64de680aff554e8afc2be9400472737bc659928 100644
--- a/boost/hana/functional/lockstep.hpp
+++ b/boost/hana/functional/lockstep.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Invoke a function with the result of invoking other functions on its
     //! arguments, in lockstep.
@@ -107,8 +107,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     };
 
-    constexpr make_pre_lockstep_t lockstep{};
+    BOOST_HANA_INLINE_VARIABLE constexpr make_pre_lockstep_t lockstep{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_LOCKSTEP_HPP
diff --git a/boost/hana/functional/on.hpp b/boost/hana/functional/on.hpp
index 59561870a37f1746c1c3a29b13b8c0519c6b3d41..5da0b14555b423eefc90f729eaf82e0ff6257ff9 100644
--- a/boost/hana/functional/on.hpp
+++ b/boost/hana/functional/on.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Invoke a function with the result of invoking another function on
     //! each argument.
@@ -76,8 +76,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     };
 
-    constexpr auto on = infix(detail::create<on_t>{});
+    BOOST_HANA_INLINE_VARIABLE constexpr auto on = infix(detail::create<on_t>{});
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_ON_HPP
diff --git a/boost/hana/functional/overload.hpp b/boost/hana/functional/overload.hpp
index d8ce96a5acdd15201b6c517f9ddc354b3904bf3d..786240ed46287ebe73c48d733a9cb533c87c4346 100644
--- a/boost/hana/functional/overload.hpp
+++ b/boost/hana/functional/overload.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/decay.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Pick one of several functions to call based on overload resolution.
     //!
@@ -81,8 +81,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     };
 
-    constexpr make_overload_t overload{};
+    BOOST_HANA_INLINE_VARIABLE constexpr make_overload_t overload{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_OVERLOAD_HPP
diff --git a/boost/hana/functional/overload_linearly.hpp b/boost/hana/functional/overload_linearly.hpp
index e4129d1169dded093fa6572b07874da1ada00e32..3a2844cf2824f5981683b2dc2ec050294d61aa53 100644
--- a/boost/hana/functional/overload_linearly.hpp
+++ b/boost/hana/functional/overload_linearly.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Call the first function that produces a valid call expression.
     //!
@@ -103,8 +103,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     };
 
-    constexpr make_overload_linearly_t overload_linearly{};
+    BOOST_HANA_INLINE_VARIABLE constexpr make_overload_linearly_t overload_linearly{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_OVERLOAD_LINEARLY_HPP
diff --git a/boost/hana/functional/partial.hpp b/boost/hana/functional/partial.hpp
index cfe981dddfb5472ee6d91efb54baf7f0710211b3..0682eb092c89433b9c505754b46e447e8de04d35 100644
--- a/boost/hana/functional/partial.hpp
+++ b/boost/hana/functional/partial.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Partially apply a function to some arguments.
     //!
@@ -98,8 +98,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     };
 
-    constexpr make_partial_t partial{};
+    BOOST_HANA_INLINE_VARIABLE constexpr make_partial_t partial{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_PARTIAL_HPP
diff --git a/boost/hana/functional/placeholder.hpp b/boost/hana/functional/placeholder.hpp
index 59dea42bfb2f17ff07a844f01023dddff90ad32a..e311d870af1e48c9fdb61cd447e3a69a4c899ea3 100644
--- a/boost/hana/functional/placeholder.hpp
+++ b/boost/hana/functional/placeholder.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Create simple functions representing C++ operators inline.
     //!
@@ -256,8 +256,8 @@ BOOST_HANA_NAMESPACE_BEGIN
 #undef BOOST_HANA_BINARY_PLACEHOLDER_OP
     } // end namespace placeholder_detail
 
-    constexpr placeholder_detail::placeholder _{};
+    BOOST_HANA_INLINE_VARIABLE constexpr placeholder_detail::placeholder _{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_PLACEHOLDER_HPP
diff --git a/boost/hana/functional/reverse_partial.hpp b/boost/hana/functional/reverse_partial.hpp
index 60fc59e4007ad616d2723202fcd281f533e728e3..437946174eb15d86876381a0a1890c3cb017268b 100644
--- a/boost/hana/functional/reverse_partial.hpp
+++ b/boost/hana/functional/reverse_partial.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-functional
     //! Partially apply a function to some arguments.
     //!
@@ -96,8 +96,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         }
     };
 
-    constexpr make_reverse_partial_t reverse_partial{};
+    BOOST_HANA_INLINE_VARIABLE constexpr make_reverse_partial_t reverse_partial{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_REVERSE_PARTIAL_HPP
diff --git a/boost/hana/fuse.hpp b/boost/hana/fuse.hpp
index 960aaee1bc99848d05f5f6d0c5e987594880084c..c5b00da8f09ed31f81bbe9c886322870e0b1baad 100644
--- a/boost/hana/fuse.hpp
+++ b/boost/hana/fuse.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/unpack.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace detail {
         template <typename F>
         struct fused {
@@ -42,6 +42,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         return detail::fused<typename detail::decay<F>::type>{static_cast<F&&>(f)};
     }
     //! @endcond
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUSE_HPP
diff --git a/boost/hana/fwd/accessors.hpp b/boost/hana/fwd/accessors.hpp
index ca337d196575682f236c95ffc33f0c4a73518084..7c82ed875e4d7f267a300c631988abc4be661cc6 100644
--- a/boost/hana/fwd/accessors.hpp
+++ b/boost/hana/fwd/accessors.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns a `Sequence` of pairs representing the accessors of the
     //! data structure.
     //! @ingroup group-Struct
@@ -43,8 +43,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct accessors_t;
 
     template <typename S>
-    constexpr accessors_t<S> accessors{};
+    BOOST_HANA_INLINE_VARIABLE constexpr accessors_t<S> accessors{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ACCESSORS_HPP
diff --git a/boost/hana/fwd/adapt_adt.hpp b/boost/hana/fwd/adapt_adt.hpp
index a7658ca628a4d41cf6071a5d9a90fdfa075804a6..d582cd3486961497f2a7a72c21f7f517b74b9a0c 100644
--- a/boost/hana/fwd/adapt_adt.hpp
+++ b/boost/hana/fwd/adapt_adt.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     // Note:
     // The weird definition as a variable seems to exploit a glitch in Doxygen
     // which makes the macro appear in the related objects of Struct (as we
@@ -43,6 +43,6 @@ BOOST_HANA_NAMESPACE_BEGIN
 #else
     // defined in <boost/hana/adapt_adt.hpp>
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ADAPT_ADT_HPP
diff --git a/boost/hana/fwd/adapt_struct.hpp b/boost/hana/fwd/adapt_struct.hpp
index b03da6463baf7d22b0ce8a23e73546c7ae3cfabe..bd92001f63afedf88038abbe22e02bd1e0160998 100644
--- a/boost/hana/fwd/adapt_struct.hpp
+++ b/boost/hana/fwd/adapt_struct.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     // Note:
     // The weird definition as a variable seems to exploit a glitch in Doxygen
     // which makes the macro appear in the related objects of Struct (as we
@@ -43,6 +43,6 @@ BOOST_HANA_NAMESPACE_BEGIN
 #else
     // defined in <boost/hana/adapt_struct.hpp>
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ADAPT_STRUCT_HPP
diff --git a/boost/hana/fwd/adjust.hpp b/boost/hana/fwd/adjust.hpp
index 8fec6f0b3da92aa164fd21b3b31f520fdb61a45d..2570d2ad4bf15abcff0e945d91d8ab72df9407a9 100644
--- a/boost/hana/fwd/adjust.hpp
+++ b/boost/hana/fwd/adjust.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Apply a function on all the elements of a structure that compare
     //! equal to some value.
     //! @ingroup group-Functor
@@ -57,8 +57,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Value&& value, F&& f) const;
     };
 
-    constexpr adjust_t adjust{};
+    BOOST_HANA_INLINE_VARIABLE constexpr adjust_t adjust{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ADJUST_HPP
diff --git a/boost/hana/fwd/adjust_if.hpp b/boost/hana/fwd/adjust_if.hpp
index 3042dc72c9e65a0cb6bbd02b0020a82209084eb9..56a066d2a6ae98a87b2abd538fea13ea290a8c81 100644
--- a/boost/hana/fwd/adjust_if.hpp
+++ b/boost/hana/fwd/adjust_if.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Apply a function on all the elements of a structure satisfying a predicate.
     //! @ingroup group-Functor
     //!
@@ -62,8 +62,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred const& pred, F const& f) const;
     };
 
-    constexpr adjust_if_t adjust_if{};
+    BOOST_HANA_INLINE_VARIABLE constexpr adjust_if_t adjust_if{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ADJUST_IF_HPP
diff --git a/boost/hana/fwd/all.hpp b/boost/hana/fwd/all.hpp
index eca239ebefc5adf44165875a3826a23479fad10a..692c1ca3ed2cd65193219ca0c0809dbbc3007f0f 100644
--- a/boost/hana/fwd/all.hpp
+++ b/boost/hana/fwd/all.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns whether all the keys of the structure are true-valued.
     //! @ingroup group-Searchable
     //!
@@ -39,8 +39,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs) const;
     };
 
-    constexpr all_t all{};
+    BOOST_HANA_INLINE_VARIABLE constexpr all_t all{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ALL_HPP
diff --git a/boost/hana/fwd/all_of.hpp b/boost/hana/fwd/all_of.hpp
index 3aabf2906398d77e726837589aa84cf449b5d3a7..f469438c5ae7290af533d18fb4cb2b00869ffae0 100644
--- a/boost/hana/fwd/all_of.hpp
+++ b/boost/hana/fwd/all_of.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns whether all the keys of the structure satisfy the `predicate`.
     //! @ingroup group-Searchable
     //!
@@ -47,8 +47,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred&& pred) const;
     };
 
-    constexpr all_of_t all_of{};
+    BOOST_HANA_INLINE_VARIABLE constexpr all_of_t all_of{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ALL_OF_HPP
diff --git a/boost/hana/fwd/and.hpp b/boost/hana/fwd/and.hpp
index 026cacabaf746ba0f310a586b2f74e7f3d13d14b..d0d23108092d0e22aa3db7bbab08320d1fbfe224 100644
--- a/boost/hana/fwd/and.hpp
+++ b/boost/hana/fwd/and.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Return whether all the arguments are true-valued.
     //! @ingroup group-Logical
     //!
@@ -46,8 +46,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x, Y&& ...y) const;
     };
 
-    constexpr and_t and_{};
+    BOOST_HANA_INLINE_VARIABLE constexpr and_t and_{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_AND_HPP
diff --git a/boost/hana/fwd/any.hpp b/boost/hana/fwd/any.hpp
index 6281236ad66d79c398f59cd573029a1df8fcf67e..32f5318c3b6c0bb84d64eaddd25424c140978e32 100644
--- a/boost/hana/fwd/any.hpp
+++ b/boost/hana/fwd/any.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns whether any key of the structure is true-valued.
     //! @ingroup group-Searchable
     //!
@@ -39,8 +39,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs) const;
     };
 
-    constexpr any_t any{};
+    BOOST_HANA_INLINE_VARIABLE constexpr any_t any{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ANY_HPP
diff --git a/boost/hana/fwd/any_of.hpp b/boost/hana/fwd/any_of.hpp
index a9408bd1b52068241c0695de8de05ea185d97b44..4969fd707bbef2407e1dd175937ba5e9f99e6a25 100644
--- a/boost/hana/fwd/any_of.hpp
+++ b/boost/hana/fwd/any_of.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns whether any key of the structure satisfies the `predicate`.
     //! @ingroup group-Searchable
     //!
@@ -46,8 +46,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred&& pred) const;
     };
 
-    constexpr any_of_t any_of{};
+    BOOST_HANA_INLINE_VARIABLE constexpr any_of_t any_of{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ANY_OF_HPP
diff --git a/boost/hana/fwd/ap.hpp b/boost/hana/fwd/ap.hpp
index 271a1631d176d57d3cfeae0cc20323afc2e0d2ce..76338f3a78b6c579354c11d254d427384b039c3c 100644
--- a/boost/hana/fwd/ap.hpp
+++ b/boost/hana/fwd/ap.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Lifted application.
     //! @ingroup group-Applicative
     //!
@@ -74,8 +74,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(F&& f, Xs&& ...xs) const;
     };
 
-    constexpr ap_t ap{};
+    BOOST_HANA_INLINE_VARIABLE constexpr ap_t ap{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_AP_HPP
diff --git a/boost/hana/fwd/append.hpp b/boost/hana/fwd/append.hpp
index 94b2105c932ac84e6cb4b6688741633696592815..3a6205d76a096916658c3b16da5e22b289608db7 100644
--- a/boost/hana/fwd/append.hpp
+++ b/boost/hana/fwd/append.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Append an element to a monadic structure.
     //! @ingroup group-MonadPlus
     //!
@@ -61,8 +61,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, X&& x) const;
     };
 
-    constexpr append_t append{};
+    BOOST_HANA_INLINE_VARIABLE constexpr append_t append{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_APPEND_HPP
diff --git a/boost/hana/fwd/at.hpp b/boost/hana/fwd/at.hpp
index ea03114ed7bfc02740cad72a78bd73781f4cacae..7d5a98dd0a8ac5ce4d29481bf410c0ea97aaeb7c 100644
--- a/boost/hana/fwd/at.hpp
+++ b/boost/hana/fwd/at.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns the `n`th element of an iterable.
     //! @ingroup group-Iterable
     //!
@@ -59,7 +59,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Xs&& xs, N const& n) const;
     };
 
-    constexpr at_t at{};
+    BOOST_HANA_INLINE_VARIABLE constexpr at_t at{};
 #endif
 
     //! Equivalent to `at`; provided for convenience.
@@ -84,6 +84,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     template <std::size_t n, typename Xs>
     constexpr decltype(auto) at_c(Xs&& xs);
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_AT_HPP
diff --git a/boost/hana/fwd/at_key.hpp b/boost/hana/fwd/at_key.hpp
index 29134565a56391cfd8310b1293a2df8faa6a7267..ead29894469dec90221ba06d04728ac604b2974d 100644
--- a/boost/hana/fwd/at_key.hpp
+++ b/boost/hana/fwd/at_key.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns the value associated to the given key in a structure, or fail.
     //! @ingroup group-Searchable
     //!
@@ -60,8 +60,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Xs&& xs, Key const& key) const;
     };
 
-    constexpr at_key_t at_key{};
+    BOOST_HANA_INLINE_VARIABLE constexpr at_key_t at_key{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_AT_KEY_HPP
diff --git a/boost/hana/fwd/back.hpp b/boost/hana/fwd/back.hpp
index 8356cddeabfad2eff9b9a50311aca9aa950d3d9e..82b0e6084123703d43606d15bdc1dc107fcdd1fd 100644
--- a/boost/hana/fwd/back.hpp
+++ b/boost/hana/fwd/back.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns the last element of a non-empty and finite iterable.
     //! @ingroup group-Iterable
     //!
@@ -41,8 +41,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Xs&& xs) const;
     };
 
-    constexpr back_t back{};
+    BOOST_HANA_INLINE_VARIABLE constexpr back_t back{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_BACK_HPP
diff --git a/boost/hana/fwd/basic_tuple.hpp b/boost/hana/fwd/basic_tuple.hpp
index 69d4073f034d5741c5304d8786ce6cd24870db4b..4563b249ad3b52d9a4d24fc38f18715cd77f939e 100644
--- a/boost/hana/fwd/basic_tuple.hpp
+++ b/boost/hana/fwd/basic_tuple.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/core/make.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-datatypes
     //! Stripped down version of `hana::tuple`.
     //!
@@ -64,7 +64,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! Example
     //! -------
     //! @include example/basic_tuple/make.cpp
-    constexpr auto make_basic_tuple = make<basic_tuple_tag>;
-BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr auto make_basic_tuple = make<basic_tuple_tag>;
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_BASIC_TUPLE_HPP
diff --git a/boost/hana/fwd/cartesian_product.hpp b/boost/hana/fwd/cartesian_product.hpp
index a3a48f23f35798d8e2a12498ad5bb98d181ba89e..a4970833664f0c796aa925ecfcce78a74b56a3b6 100644
--- a/boost/hana/fwd/cartesian_product.hpp
+++ b/boost/hana/fwd/cartesian_product.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Computes the cartesian product of a sequence of sequences.
     //! @ingroup group-Sequence
     //!
@@ -55,8 +55,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs) const;
     };
 
-    constexpr cartesian_product_t cartesian_product{};
+    BOOST_HANA_INLINE_VARIABLE constexpr cartesian_product_t cartesian_product{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CARTESIAN_PRODUCT_HPP
diff --git a/boost/hana/fwd/chain.hpp b/boost/hana/fwd/chain.hpp
index aa7f311057017e73c77fa83aa8f92b17d96b9bbd..c41eed8dafbe601b0b8862633cb0bbc3274b7d36 100644
--- a/boost/hana/fwd/chain.hpp
+++ b/boost/hana/fwd/chain.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Feed a monadic value into a monadic computation.
     //! @ingroup group-Monad
     //!
@@ -60,8 +60,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Xs&& xs, F&& f) const;
     };
 
-    constexpr chain_t chain{};
+    BOOST_HANA_INLINE_VARIABLE constexpr chain_t chain{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CHAIN_HPP
diff --git a/boost/hana/fwd/comparing.hpp b/boost/hana/fwd/comparing.hpp
index 376ab173c7b81b906126e304af8f19167acc2044..ec51a5fd1ae5b46a238cd6bd8a8505e315649b2e 100644
--- a/boost/hana/fwd/comparing.hpp
+++ b/boost/hana/fwd/comparing.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns a function performing `equal` after applying a transformation
     //! to both arguments.
     //! @ingroup group-Comparable
@@ -58,8 +58,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(F&& f) const;
     };
 
-    constexpr comparing_t comparing{};
+    BOOST_HANA_INLINE_VARIABLE constexpr comparing_t comparing{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_COMPARING_HPP
diff --git a/boost/hana/fwd/concat.hpp b/boost/hana/fwd/concat.hpp
index 140c84790930cf4d6adce7fd61a87a9e39af9666..6acd5341510c01638da2a842f25253f8740ffb95 100644
--- a/boost/hana/fwd/concat.hpp
+++ b/boost/hana/fwd/concat.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Combine two monadic structures together.
     //! @ingroup group-MonadPlus
     //!
@@ -56,8 +56,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Ys&& ys) const;
     };
 
-    constexpr concat_t concat{};
+    BOOST_HANA_INLINE_VARIABLE constexpr concat_t concat{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCAT_HPP
diff --git a/boost/hana/fwd/concept/applicative.hpp b/boost/hana/fwd/concept/applicative.hpp
index 2c8677940c54d73aefff65d5cb90bbfb8821e7a9..62e3a00c838949ac879c705e28f05764c30beebc 100644
--- a/boost/hana/fwd/concept/applicative.hpp
+++ b/boost/hana/fwd/concept/applicative.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Applicative Applicative
     //! The `Applicative` concept represents `Functor`s with the ability
@@ -112,6 +112,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [1]: https://wiki.haskell.org/Typeclassopedia#Applicative
     template <typename A>
     struct Applicative;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_APPLICATIVE_HPP
diff --git a/boost/hana/fwd/concept/comonad.hpp b/boost/hana/fwd/concept/comonad.hpp
index b2693078b05f86ba412552fa61bb625bf5357a73..6c357a4216f4dc7f647cb5f30e818f77b7c2f864 100644
--- a/boost/hana/fwd/concept/comonad.hpp
+++ b/boost/hana/fwd/concept/comonad.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     // Note: We use a multiline C++ comment because there's a double backslash
     // symbol in the documentation (for LaTeX), which triggers
     //      warning: multi-line comment [-Wcomment]
@@ -106,6 +106,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     */
     template <typename W>
     struct Comonad;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_COMONAD_HPP
diff --git a/boost/hana/fwd/concept/comparable.hpp b/boost/hana/fwd/concept/comparable.hpp
index db1b45d9475ae4ceb677db3b6ae0163791ccf133..6cc0508c8532ec49e1a7e66574ed9e3883aeaf77 100644
--- a/boost/hana/fwd/concept/comparable.hpp
+++ b/boost/hana/fwd/concept/comparable.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Comparable Comparable
     //! The `Comparable` concept defines equality and inequality.
@@ -155,6 +155,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [4]: http://en.wikipedia.org/wiki/Injective_function
     template <typename T>
     struct Comparable;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_COMPARABLE_HPP
diff --git a/boost/hana/fwd/concept/constant.hpp b/boost/hana/fwd/concept/constant.hpp
index 4a4799ac6e2970a333e14f8d1da2dd1fcb265171..f0370964bfc938a3b0a7c4191dadd86908d1dab0 100644
--- a/boost/hana/fwd/concept/constant.hpp
+++ b/boost/hana/fwd/concept/constant.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Constant Constant
     //! The `Constant` concept represents data that can be manipulated at
@@ -205,6 +205,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [1]: http://en.cppreference.com/w/cpp/named_req/LiteralType
     template <typename C>
     struct Constant;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_CONSTANT_HPP
diff --git a/boost/hana/fwd/concept/euclidean_ring.hpp b/boost/hana/fwd/concept/euclidean_ring.hpp
index 8b8744c29d51c818e76bdd8deb3a552c5caae7ea..7e68cc6a2a46c117f972337b7a171680d2a0f564 100644
--- a/boost/hana/fwd/concept/euclidean_ring.hpp
+++ b/boost/hana/fwd/concept/euclidean_ring.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-EuclideanRing Euclidean Ring
     //! The `EuclideanRing` concept represents a commutative `Ring` that
@@ -112,6 +112,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [1]: https://en.wikipedia.org/wiki/Euclidean_domain
     template <typename R>
     struct EuclideanRing;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_EUCLIDEAN_RING_HPP
diff --git a/boost/hana/fwd/concept/foldable.hpp b/boost/hana/fwd/concept/foldable.hpp
index 09de17045537a689ab4b7710e93ca79379465383..c51f9219d4aff987c5002ab6b210a974cb4fa76e 100644
--- a/boost/hana/fwd/concept/foldable.hpp
+++ b/boost/hana/fwd/concept/foldable.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Foldable Foldable
     //! The `Foldable` concept represents data structures that can be reduced
@@ -136,6 +136,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! course result in different effects.
     template <typename T>
     struct Foldable;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_FOLDABLE_HPP
diff --git a/boost/hana/fwd/concept/functor.hpp b/boost/hana/fwd/concept/functor.hpp
index f46ad24c73c23dbd276a31ff31c44271de73023d..cc673f81ccd7b4b0ead68881f568aca900582f3c 100644
--- a/boost/hana/fwd/concept/functor.hpp
+++ b/boost/hana/fwd/concept/functor.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Functor Functor
     //! The `Functor` concept represents types that can be mapped over.
@@ -134,6 +134,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [3]: http://en.wikipedia.org/wiki/Category_theory
     template <typename F>
     struct Functor;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_FUNCTOR_HPP
diff --git a/boost/hana/fwd/concept/group.hpp b/boost/hana/fwd/concept/group.hpp
index 6afec945028dd6593917eb736d6dc73f7e5eb7b7..bde978dc1829a1f19361860a4516e514eb0553f8 100644
--- a/boost/hana/fwd/concept/group.hpp
+++ b/boost/hana/fwd/concept/group.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Group Group
     //! The `Group` concept represents `Monoid`s where all objects have
@@ -106,6 +106,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [2]: http://en.wikipedia.org/wiki/Group_homomorphism
     template <typename G>
     struct Group;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_GROUP_HPP
diff --git a/boost/hana/fwd/concept/hashable.hpp b/boost/hana/fwd/concept/hashable.hpp
index 2fc4977ba9a2e8df488e05d064f71304d4487946..f545a078dd4adee3125391171b14d9e09d5cc0dd 100644
--- a/boost/hana/fwd/concept/hashable.hpp
+++ b/boost/hana/fwd/concept/hashable.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Hashable Hashable
     //! The `Hashable` concept represents objects that can be normalized to
@@ -63,6 +63,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! types, and `signed long long` for signed integral types.
     template <typename T>
     struct Hashable;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_HASHABLE_HPP
diff --git a/boost/hana/fwd/concept/integral_constant.hpp b/boost/hana/fwd/concept/integral_constant.hpp
index 161062e2be1f688deb350d5a56ecbd77ed318fc2..152169397e18fb1fccb2f29efd5bbb876df810f5 100644
--- a/boost/hana/fwd/concept/integral_constant.hpp
+++ b/boost/hana/fwd/concept/integral_constant.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! The `IntegralConstant` concept represents compile-time integral values.
     //!
@@ -68,6 +68,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! `hana::integral_constant`
     template <typename C>
     struct IntegralConstant;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_INTEGRAL_CONSTANT_HPP
diff --git a/boost/hana/fwd/concept/iterable.hpp b/boost/hana/fwd/concept/iterable.hpp
index 59c8520b62081ee096ce1d51b166873b0189f250..feb4b58dc09e3a16cf586712b844ad30b28f4e17 100644
--- a/boost/hana/fwd/concept/iterable.hpp
+++ b/boost/hana/fwd/concept/iterable.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Iterable Iterable
     //! The `Iterable` concept represents data structures supporting external
@@ -144,6 +144,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [1]: https://github.com/boostorg/hana/issues/40
     template <typename It>
     struct Iterable;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_ITERABLE_HPP
diff --git a/boost/hana/fwd/concept/logical.hpp b/boost/hana/fwd/concept/logical.hpp
index f9cfde986c84635f01f538ccfb5f4c6da5863870..e4a62df5ba0b0674baeb98f96e0f64615ffc9214 100644
--- a/boost/hana/fwd/concept/logical.hpp
+++ b/boost/hana/fwd/concept/logical.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Logical Logical
     //! The `Logical` concept represents types with a truth value.
@@ -161,6 +161,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [1]: http://en.wikipedia.org/wiki/Boolean_algebra_(structure)
     template <typename L>
     struct Logical;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_LOGICAL_HPP
diff --git a/boost/hana/fwd/concept/metafunction.hpp b/boost/hana/fwd/concept/metafunction.hpp
index a480c0b1d41406c30b7a3aab14494219cc1ff631..ee67798cb238fc77208ca391d7fe6b8a7c6d4907 100644
--- a/boost/hana/fwd/concept/metafunction.hpp
+++ b/boost/hana/fwd/concept/metafunction.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Metafunction Metafunction
     //! A `Metafunction` is a function that takes `hana::type`s as inputs and
@@ -94,6 +94,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [2]: http://www.boost.org/doc/libs/release/libs/mpl/doc/refmanual/metafunction-class.html
     template <typename F>
     struct Metafunction;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_METAFUNCTION_HPP
diff --git a/boost/hana/fwd/concept/monad.hpp b/boost/hana/fwd/concept/monad.hpp
index b310868e44625f7b43faddead239dd92b2e2fa9f..b8cfea7b8690511cab9d0df1202fdc0eef1ae45f 100644
--- a/boost/hana/fwd/concept/monad.hpp
+++ b/boost/hana/fwd/concept/monad.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Monad Monad
     //! The `Monad` concept represents `Applicative`s with the ability to
@@ -193,6 +193,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [2]: https://wiki.haskell.org/Typeclassopedia#Monad
     template <typename M>
     struct Monad;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_MONAD_HPP
diff --git a/boost/hana/fwd/concept/monad_plus.hpp b/boost/hana/fwd/concept/monad_plus.hpp
index dcdf65e210c4de7e6f3b5085c3c698dc7e6f1d7f..791b1e0bee32defc949013f3b3ffac608deb7ce9 100644
--- a/boost/hana/fwd/concept/monad_plus.hpp
+++ b/boost/hana/fwd/concept/monad_plus.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-MonadPlus MonadPlus
     //! The `MonadPlus` concept represents Monads with a monoidal structure.
@@ -84,6 +84,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [1]: https://en.wikibooks.org/wiki/Haskell/MonadPlus
     template <typename M>
     struct MonadPlus;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_MONAD_PLUS_HPP
diff --git a/boost/hana/fwd/concept/monoid.hpp b/boost/hana/fwd/concept/monoid.hpp
index 381e29dff7a97676376a181788799574ce7d9963..05b688fafc2f14b03ded296c0aed233e29799c98 100644
--- a/boost/hana/fwd/concept/monoid.hpp
+++ b/boost/hana/fwd/concept/monoid.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Monoid Monoid
     //! The `Monoid` concept represents data types with an associative
@@ -96,6 +96,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [2]: http://en.wikipedia.org/wiki/Monoid#Monoid_homomorphisms
     template <typename M>
     struct Monoid;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_MONOID_HPP
diff --git a/boost/hana/fwd/concept/orderable.hpp b/boost/hana/fwd/concept/orderable.hpp
index e7730ee2998d0cb895cbab07e448108f9b960128..e7ad9c8364225b896877646a5951ebe05440cc3b 100644
--- a/boost/hana/fwd/concept/orderable.hpp
+++ b/boost/hana/fwd/concept/orderable.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Orderable Orderable
     //! The `Orderable` concept represents totally ordered data types.
@@ -182,6 +182,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [4]: http://en.wikipedia.org/wiki/Strict_weak_ordering
     template <typename Ord>
     struct Orderable;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_ORDERABLE_HPP
diff --git a/boost/hana/fwd/concept/product.hpp b/boost/hana/fwd/concept/product.hpp
index 0d029fdb11c0a7bdbcc3d2ca3be7f8e1725d3643..0948d1e55c9e994eefd10cf365bce99de6c2b856 100644
--- a/boost/hana/fwd/concept/product.hpp
+++ b/boost/hana/fwd/concept/product.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Product Product
     //! Represents types that are generic containers of two elements.
@@ -98,6 +98,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [1]: http://en.wikipedia.org/wiki/Product_(category_theory)
     template <typename P>
     struct Product;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_PRODUCT_HPP
diff --git a/boost/hana/fwd/concept/ring.hpp b/boost/hana/fwd/concept/ring.hpp
index 45b301f27240d970ba1848cb0721bd070a600e33..be97932bd717685b70e6c1a9e96de6b28d3564da 100644
--- a/boost/hana/fwd/concept/ring.hpp
+++ b/boost/hana/fwd/concept/ring.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Ring Ring
     //! The `Ring` concept represents `Group`s that also form a `Monoid`
@@ -101,6 +101,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! [2]: http://en.wikipedia.org/wiki/Ring_homomorphism
     template <typename R>
     struct Ring;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_RING_HPP
diff --git a/boost/hana/fwd/concept/searchable.hpp b/boost/hana/fwd/concept/searchable.hpp
index 2c1e22fc4a02d80593695584800ff5f07e2f607f..af6eaaae4eb02b618d1cfc8f11a0e716bdb2a804 100644
--- a/boost/hana/fwd/concept/searchable.hpp
+++ b/boost/hana/fwd/concept/searchable.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Searchable Searchable
     //! The `Searchable` concept represents structures that can be searched.
@@ -138,6 +138,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! transformation.
     template <typename S>
     struct Searchable;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_SEARCHABLE_HPP
diff --git a/boost/hana/fwd/concept/sequence.hpp b/boost/hana/fwd/concept/sequence.hpp
index 84cedd1263da1d2648ed3bc8a6d6313d0e20d9a9..b70a6b2ef390652e5c90af95345bb7d58b7d0053 100644
--- a/boost/hana/fwd/concept/sequence.hpp
+++ b/boost/hana/fwd/concept/sequence.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Sequence Sequence
     //! The `Sequence` concept represents generic index-based sequences.
@@ -160,6 +160,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     template <typename S, typename = void>
     struct Sequence : Sequence<S, when<true>> { };
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_SEQUENCE_HPP
diff --git a/boost/hana/fwd/concept/struct.hpp b/boost/hana/fwd/concept/struct.hpp
index d9d0cffb582d765990448ac56c4d2148709361f8..39e2e8cc6d8c19c0f69473920535126ac5ea7b54 100644
--- a/boost/hana/fwd/concept/struct.hpp
+++ b/boost/hana/fwd/concept/struct.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-concepts
     //! @defgroup group-Struct Struct
     //! The `Struct` concept represents `struct`-like user-defined types.
@@ -151,6 +151,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! @include example/struct/searchable.cpp
     template <typename S>
     struct Struct;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONCEPT_STRUCT_HPP
diff --git a/boost/hana/fwd/contains.hpp b/boost/hana/fwd/contains.hpp
index eb338281c1df4b9b69b0c6452af3353c2de30510..b49301c384c880ba34ac249dbbe92bc3df9bb0bc 100644
--- a/boost/hana/fwd/contains.hpp
+++ b/boost/hana/fwd/contains.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/infix.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns whether the key occurs in the structure.
     //! @ingroup group-Searchable
     //!
@@ -51,7 +51,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Key&& key) const;
     };
 
-    constexpr auto contains = hana::infix(contains_t{});
+    BOOST_HANA_INLINE_VARIABLE constexpr auto contains = hana::infix(contains_t{});
 #endif
 
     //! Return whether the key occurs in the structure.
@@ -67,7 +67,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! Example
     //! -------
     //! @include example/in.cpp
-    constexpr auto in = hana::infix(hana::flip(hana::contains));
-BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr auto in = hana::infix(hana::flip(hana::contains));
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CONTAINS_HPP
diff --git a/boost/hana/fwd/core/common.hpp b/boost/hana/fwd/core/common.hpp
index d2dcac59f77b2d07eae5b1ee60b59f5348cf8386..f1c9ec1cb41bc6dea239c73f80c69646db2f7844 100644
--- a/boost/hana/fwd/core/common.hpp
+++ b/boost/hana/fwd/core/common.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-core
     //! %Metafunction returning the common data type between two data types.
     //!
@@ -98,6 +98,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! @include example/core/common/common_t.cpp
     template <typename T, typename U>
     using common_t = typename common<T, U>::type;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CORE_COMMON_HPP
diff --git a/boost/hana/fwd/core/default.hpp b/boost/hana/fwd/core/default.hpp
index 978c9a5f0c4871ce20ef5f7bce365e7e5fc18dbc..51a9ef96f0a7d9aa62b9da3856302c92951089b7 100644
--- a/boost/hana/fwd/core/default.hpp
+++ b/boost/hana/fwd/core/default.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-core
     //! Mark a tag-dispatched method implementation as a default implementation.
     //!
@@ -51,6 +51,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     template <typename T, typename = void>
     struct is_default;
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CORE_DEFAULT_HPP
diff --git a/boost/hana/fwd/core/is_a.hpp b/boost/hana/fwd/core/is_a.hpp
index 956549aa16ac381d0ff7fe646773dcf2e7b91231..9d896d01484bb2d7352d16188285a92305ccf6c5 100644
--- a/boost/hana/fwd/core/is_a.hpp
+++ b/boost/hana/fwd/core/is_a.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-core
     //! Returns whether the tag of an object matches a given tag.
     //!
@@ -43,7 +43,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct is_a_t;
 
     template <typename Tag, typename ...T>
-    constexpr is_a_t<Tag, T...> is_a{};
+    BOOST_HANA_INLINE_VARIABLE constexpr is_a_t<Tag, T...> is_a{};
 #endif
 
     //! @ingroup group-core
@@ -54,8 +54,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     constexpr auto is_an = is_a<Tag, T...>;
 #else
     template <typename Tag, typename ...T>
-    constexpr is_a_t<Tag, T...> is_an{};
+    BOOST_HANA_INLINE_VARIABLE constexpr is_a_t<Tag, T...> is_an{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CORE_IS_A_HPP
diff --git a/boost/hana/fwd/core/make.hpp b/boost/hana/fwd/core/make.hpp
index 0ed5d0f19e4a028070ec837e4f9bd203b8839a6c..35185c6548a90641759c114ac6d6e65d2227b344 100644
--- a/boost/hana/fwd/core/make.hpp
+++ b/boost/hana/fwd/core/make.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-core
     //! Create an object of the given tag with the given arguments.
     //!
@@ -63,8 +63,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <typename Tag>
-    constexpr make_t<Tag> make{};
+    BOOST_HANA_INLINE_VARIABLE constexpr make_t<Tag> make{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CORE_MAKE_HPP
diff --git a/boost/hana/fwd/core/tag_of.hpp b/boost/hana/fwd/core/tag_of.hpp
index 5d490dd717e257d015db2f6903a75b807e764037..92d869b938030854d183348431e9516a0b43167e 100644
--- a/boost/hana/fwd/core/tag_of.hpp
+++ b/boost/hana/fwd/core/tag_of.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-core
     //! %Metafunction returning the tag associated to `T`.
     //!
@@ -115,6 +115,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! @include example/core/tag_of_t.cpp
     template <typename T>
     using tag_of_t = typename hana::tag_of<T>::type;
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CORE_TAG_OF_HPP
diff --git a/boost/hana/fwd/core/to.hpp b/boost/hana/fwd/core/to.hpp
index 108484c2ce7605f7bb8a3bd4d8e29f8482397a00..60844eb7f4230e6005fc1de89826c411c5f2081a 100644
--- a/boost/hana/fwd/core/to.hpp
+++ b/boost/hana/fwd/core/to.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-core
     //! Converts an object from one data type to another.
     //!
@@ -108,7 +108,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <typename To>
-    constexpr to_t<To> to{};
+    BOOST_HANA_INLINE_VARIABLE constexpr to_t<To> to{};
 #endif
 
     //! @ingroup group-core
@@ -169,6 +169,6 @@ BOOST_HANA_NAMESPACE_BEGIN
     template <typename From, typename To, typename = void>
     struct is_embedded;
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CORE_TO_HPP
diff --git a/boost/hana/fwd/core/when.hpp b/boost/hana/fwd/core/when.hpp
index cc7659628dca7dbcf7875bcccd7159658505f97c..cedcd14ebc58fc340da73349b415ec78e43f7915 100644
--- a/boost/hana/fwd/core/when.hpp
+++ b/boost/hana/fwd/core/when.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-core
     //! Enable a partial specialization only if a boolean condition is true.
     //!
@@ -69,6 +69,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         core_detail::always_true<Dummy...>::value
     >;
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CORE_WHEN_HPP
diff --git a/boost/hana/fwd/count.hpp b/boost/hana/fwd/count.hpp
index 3bfdda53d6a7128fb4cb7c423928d49c320fbd0c..00c5f828a5b003fe99503e2811e1a0141fd8bf86 100644
--- a/boost/hana/fwd/count.hpp
+++ b/boost/hana/fwd/count.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Return the number of elements in the structure that compare equal to
     //! a given value.
     //! @ingroup group-Foldable
@@ -50,8 +50,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Value&& value) const;
     };
 
-    constexpr count_t count{};
+    BOOST_HANA_INLINE_VARIABLE constexpr count_t count{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_COUNT_HPP
diff --git a/boost/hana/fwd/count_if.hpp b/boost/hana/fwd/count_if.hpp
index 8be0a426389bca82c90fc57929264b81e7049ea0..2d8bb81bb0e2ce7655bddc9d77bbd2b8912f4669 100644
--- a/boost/hana/fwd/count_if.hpp
+++ b/boost/hana/fwd/count_if.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Return the number of elements in the structure for which the
     //! `predicate` is satisfied.
     //! @ingroup group-Foldable
@@ -49,8 +49,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred&& pred) const;
     };
 
-    constexpr count_if_t count_if{};
+    BOOST_HANA_INLINE_VARIABLE constexpr count_if_t count_if{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_COUNT_IF_HPP
diff --git a/boost/hana/fwd/cycle.hpp b/boost/hana/fwd/cycle.hpp
index 268e7daf432b08bcf0c375e6ea2c8ea658d1e6f8..6a3a76e3a9a0bdf2488cd27adc89000b5c7399db 100644
--- a/boost/hana/fwd/cycle.hpp
+++ b/boost/hana/fwd/cycle.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Combine a monadic structure with itself `n` times.
     //! @ingroup group-MonadPlus
     //!
@@ -69,8 +69,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, N const& n) const;
     };
 
-    constexpr cycle_t cycle{};
+    BOOST_HANA_INLINE_VARIABLE constexpr cycle_t cycle{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_CYCLE_HPP
diff --git a/boost/hana/fwd/define_struct.hpp b/boost/hana/fwd/define_struct.hpp
index 831f6872a4e973925212e0c246096c328948b8d1..39537b8802deacf0c7fb46250fad1460637f6e92 100644
--- a/boost/hana/fwd/define_struct.hpp
+++ b/boost/hana/fwd/define_struct.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     // Note:
     // The weird definition as a variable seems to exploit a glitch in Doxygen
     // which makes the macro appear in the related objects of Struct (as we
@@ -43,6 +43,6 @@ BOOST_HANA_NAMESPACE_BEGIN
 #else
     // defined in <boost/hana/define_struct.hpp>
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_DEFINE_STRUCT_HPP
diff --git a/boost/hana/fwd/difference.hpp b/boost/hana/fwd/difference.hpp
index d96142b5b944280746ce9c6cce6c5d3b7794e99a..d5e342d380687ae4eb24c35b8b95f5a906e4cdab 100644
--- a/boost/hana/fwd/difference.hpp
+++ b/boost/hana/fwd/difference.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     // Note: This function is documented per datatype/concept only.
     //! @cond
     template <typename S, typename = void>
@@ -26,7 +26,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&&, Ys&&) const;
     };
 
-    constexpr difference_t difference{};
-BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr difference_t difference{};
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_DIFFERENCE_HPP
diff --git a/boost/hana/fwd/div.hpp b/boost/hana/fwd/div.hpp
index 6f35b4abe391259788904008d43478bba7b18582..c7137974c25ce82ebb53caec11bfad70384156d0 100644
--- a/boost/hana/fwd/div.hpp
+++ b/boost/hana/fwd/div.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Generalized integer division.
     //! @ingroup group-EuclideanRing
     //!
@@ -52,8 +52,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x, Y&& y) const;
     };
 
-    constexpr div_t div{};
+    BOOST_HANA_INLINE_VARIABLE constexpr div_t div{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_DIV_HPP
diff --git a/boost/hana/fwd/drop_back.hpp b/boost/hana/fwd/drop_back.hpp
index 440e925322417d0f1254c59a61cb3de90f04c05b..7d81ef2cfe888989d571f7eed1bc489b1c277052 100644
--- a/boost/hana/fwd/drop_back.hpp
+++ b/boost/hana/fwd/drop_back.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Drop the last `n` elements of a finite sequence, and return the rest.
     //! @ingroup group-Sequence
     //!
@@ -56,8 +56,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs) const;
     };
 
-    constexpr drop_back_t drop_back{};
+    BOOST_HANA_INLINE_VARIABLE constexpr drop_back_t drop_back{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_DROP_BACK_HPP
diff --git a/boost/hana/fwd/drop_front.hpp b/boost/hana/fwd/drop_front.hpp
index 298499180c0af6135b3efae232f2d6ced04a8048..e48cb27cbee148fa4aa20d4335208b347c18e926 100644
--- a/boost/hana/fwd/drop_front.hpp
+++ b/boost/hana/fwd/drop_front.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Drop the first `n` elements of an iterable, and return the rest.
     //! @ingroup group-Iterable
     //!
@@ -59,8 +59,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs) const;
     };
 
-    constexpr drop_front_t drop_front{};
+    BOOST_HANA_INLINE_VARIABLE constexpr drop_front_t drop_front{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_DROP_FRONT_HPP
diff --git a/boost/hana/fwd/drop_front_exactly.hpp b/boost/hana/fwd/drop_front_exactly.hpp
index 17a55e6d66f0a1a8338407b8b812191ed0abba7c..8e492f2a9ef4917ef717d06d20fc9e9363db02ed 100644
--- a/boost/hana/fwd/drop_front_exactly.hpp
+++ b/boost/hana/fwd/drop_front_exactly.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Drop the first `n` elements of an iterable, and return the rest.
     //! @ingroup group-Iterable
     //!
@@ -60,8 +60,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs) const;
     };
 
-    constexpr drop_front_exactly_t drop_front_exactly{};
+    BOOST_HANA_INLINE_VARIABLE constexpr drop_front_exactly_t drop_front_exactly{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_DROP_FRONT_EXACTLY_HPP
diff --git a/boost/hana/fwd/drop_while.hpp b/boost/hana/fwd/drop_while.hpp
index 2d5557e5a7b4d5b09cee408a60a26294b1457883..33d8b2e2660da416ce4a20c9b4e78ec4ea8e096f 100644
--- a/boost/hana/fwd/drop_while.hpp
+++ b/boost/hana/fwd/drop_while.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Drop elements from an iterable up to, but excluding, the first
     //! element for which the `predicate` is not satisfied.
     //! @ingroup group-Iterable
@@ -53,8 +53,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred&& pred) const;
     };
 
-    constexpr drop_while_t drop_while{};
+    BOOST_HANA_INLINE_VARIABLE constexpr drop_while_t drop_while{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWDDROP_WHILE_HPP
diff --git a/boost/hana/fwd/duplicate.hpp b/boost/hana/fwd/duplicate.hpp
index bac61e0bd982ff9456da3d5262cb99534bfd29d3..02bff58095c50e7a2e40c552518ff4eb6bfde8d6 100644
--- a/boost/hana/fwd/duplicate.hpp
+++ b/boost/hana/fwd/duplicate.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Add an extra layer of comonadic context to a comonadic value.
     //! @ingroup group-Comonad
     //!
@@ -50,8 +50,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(W_&& w) const;
     };
 
-    constexpr duplicate_t duplicate{};
+    BOOST_HANA_INLINE_VARIABLE constexpr duplicate_t duplicate{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_DUPLICATE_HPP
diff --git a/boost/hana/fwd/empty.hpp b/boost/hana/fwd/empty.hpp
index 719f58055fb03eccb730baa608b749b814cd95aa..5dd73956db2857b8d7793f7e6d64899311a7e7b1 100644
--- a/boost/hana/fwd/empty.hpp
+++ b/boost/hana/fwd/empty.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Identity of the monadic combination `concat`.
     //! @ingroup group-MonadPlus
     //!
@@ -46,8 +46,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <typename M>
-    constexpr empty_t<M> empty{};
+    BOOST_HANA_INLINE_VARIABLE constexpr empty_t<M> empty{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_EMPTY_HPP
diff --git a/boost/hana/fwd/equal.hpp b/boost/hana/fwd/equal.hpp
index e9f8c4bd6e7898ea5013be8036b7d4d208493e51..fece3032b08e9f70fbd8fa83db8c68ca280952db 100644
--- a/boost/hana/fwd/equal.hpp
+++ b/boost/hana/fwd/equal.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/nested_to_fwd.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns a `Logical` representing whether `x` is equal to `y`.
     //! @ingroup group-Comparable
     //!
@@ -73,8 +73,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(X&& x, Y&& y) const;
     };
 
-    constexpr equal_t equal{};
+    BOOST_HANA_INLINE_VARIABLE constexpr equal_t equal{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_EQUAL_HPP
diff --git a/boost/hana/fwd/erase_key.hpp b/boost/hana/fwd/erase_key.hpp
index 49471d61cff49e4d5e2ce7d6d53eb8fc703677c2..705b834aa5c9d07a8534cbab398d4f32cc8239e2 100644
--- a/boost/hana/fwd/erase_key.hpp
+++ b/boost/hana/fwd/erase_key.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     // Note: This function is documented per datatype/concept only.
     //! @cond
     template <typename T, typename = void>
@@ -26,7 +26,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Set&& set, Args&& ...args) const;
     };
 
-    constexpr erase_key_t erase_key{};
-BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr erase_key_t erase_key{};
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ERASE_KEY_HPP
diff --git a/boost/hana/fwd/eval.hpp b/boost/hana/fwd/eval.hpp
index d068f992f5328af0992d7e3e60755dc3a4aebb78..201eaa27bdffc6d4b38de3e4171197e6113eb64b 100644
--- a/boost/hana/fwd/eval.hpp
+++ b/boost/hana/fwd/eval.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Evaluate a lazy value and return it.
     //! @relates hana::lazy
     //!
@@ -51,8 +51,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Expr&& expr) const;
     };
 
-    constexpr eval_t eval{};
+    BOOST_HANA_INLINE_VARIABLE constexpr eval_t eval{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_EVAL_HPP
diff --git a/boost/hana/fwd/eval_if.hpp b/boost/hana/fwd/eval_if.hpp
index 2bc8736b12cbf14f081c4a5561b688b30bf54dc7..05deea72ac2a08bcf16214d29f57f412165287c9 100644
--- a/boost/hana/fwd/eval_if.hpp
+++ b/boost/hana/fwd/eval_if.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Conditionally execute one of two branches based on a condition.
     //! @ingroup group-Logical
     //!
@@ -148,8 +148,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Cond&& cond, Then&& then, Else&& else_) const;
     };
 
-    constexpr eval_if_t eval_if{};
+    BOOST_HANA_INLINE_VARIABLE constexpr eval_if_t eval_if{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_EVAL_IF_HPP
diff --git a/boost/hana/fwd/extend.hpp b/boost/hana/fwd/extend.hpp
index 65b68d8011dce43cf30542d40f9d3b88ddf2ca52..c1a08b3d0c38537aa877b7a13fb2b3a557e29bf7 100644
--- a/boost/hana/fwd/extend.hpp
+++ b/boost/hana/fwd/extend.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Comonadic application of a function to a comonadic value.
     //! @ingroup group-Comonad
     //!
@@ -55,8 +55,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(W_&& w, F&& f) const;
     };
 
-    constexpr extend_t extend{};
+    BOOST_HANA_INLINE_VARIABLE constexpr extend_t extend{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_EXTEND_HPP
diff --git a/boost/hana/fwd/extract.hpp b/boost/hana/fwd/extract.hpp
index 1e717271438cf550f8281b641ca913f972e442db..0a00760b7b950831e9c7ab06f9d64473e60afd4c 100644
--- a/boost/hana/fwd/extract.hpp
+++ b/boost/hana/fwd/extract.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Extract a value in a given comonadic context.
     //! @ingroup group-Comonad
     //!
@@ -51,8 +51,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(W_&& w) const;
     };
 
-    constexpr extract_t extract{};
+    BOOST_HANA_INLINE_VARIABLE constexpr extract_t extract{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_EXTRACT_HPP
diff --git a/boost/hana/fwd/fill.hpp b/boost/hana/fwd/fill.hpp
index 6946c6ffd8ed9401dce969a77a398cf1ac1ef951..6fe92d343a886d6286515382d401a22bbd70bfff 100644
--- a/boost/hana/fwd/fill.hpp
+++ b/boost/hana/fwd/fill.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Replace all the elements of a structure with a fixed value.
     //! @ingroup group-Functor
     //!
@@ -50,8 +50,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Value&& value) const;
     };
 
-    constexpr fill_t fill{};
+    BOOST_HANA_INLINE_VARIABLE constexpr fill_t fill{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_FILL_HPP
diff --git a/boost/hana/fwd/filter.hpp b/boost/hana/fwd/filter.hpp
index f31b30df52b3461b5c6defb5e3cafb1f9a3a0535..c228b783da807b51ce1f6d98361712ba48a0f0db 100644
--- a/boost/hana/fwd/filter.hpp
+++ b/boost/hana/fwd/filter.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Filter a monadic structure using a custom predicate.
     //! @ingroup group-MonadPlus
     //!
@@ -74,8 +74,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred&& pred) const;
     };
 
-    constexpr filter_t filter{};
+    BOOST_HANA_INLINE_VARIABLE constexpr filter_t filter{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_FILTER_HPP
diff --git a/boost/hana/fwd/find.hpp b/boost/hana/fwd/find.hpp
index cc88d6f23937103b635abb5d5d389b915082a9ff..1bafce5de51f01561de912a1e0f6d4e0ee4f17fc 100644
--- a/boost/hana/fwd/find.hpp
+++ b/boost/hana/fwd/find.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Finds the value associated to the given key in a structure.
     //! @ingroup group-Searchable
     //!
@@ -53,8 +53,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Key const& key) const;
     };
 
-    constexpr find_t find{};
+    BOOST_HANA_INLINE_VARIABLE constexpr find_t find{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_FIND_HPP
diff --git a/boost/hana/fwd/find_if.hpp b/boost/hana/fwd/find_if.hpp
index d6fca44600789cbc46d75283ad61b37a7a65bac7..576fce8f5cc81a9397e54c2bc2da24080f26029c 100644
--- a/boost/hana/fwd/find_if.hpp
+++ b/boost/hana/fwd/find_if.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Finds the value associated to the first key satisfying a predicate.
     //! @ingroup group-Searchable
     //!
@@ -50,8 +50,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred&& pred) const;
     };
 
-    constexpr find_if_t find_if{};
+    BOOST_HANA_INLINE_VARIABLE constexpr find_if_t find_if{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_FIND_IF_HPP
diff --git a/boost/hana/fwd/first.hpp b/boost/hana/fwd/first.hpp
index 0a62a8344f7cc42b72cbb6a09a66b9874f0df0ea..81b464a65054b7d4197326b2914543fb5c4e7b3b 100644
--- a/boost/hana/fwd/first.hpp
+++ b/boost/hana/fwd/first.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns the first element of a pair.
     //! @ingroup group-Product
     //!
@@ -42,8 +42,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Pair&& pair) const;
     };
 
-    constexpr first_t first{};
+    BOOST_HANA_INLINE_VARIABLE constexpr first_t first{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_FIRST_HPP
diff --git a/boost/hana/fwd/flatten.hpp b/boost/hana/fwd/flatten.hpp
index f0e319a13121643a8d6e16451571a75258689c65..1b944f49aa2b5773c6bcfaa749d9bc76365ed740 100644
--- a/boost/hana/fwd/flatten.hpp
+++ b/boost/hana/fwd/flatten.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Collapse two levels of monadic structure into a single level.
     //! @ingroup group-Monad
     //!
@@ -56,8 +56,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs) const;
     };
 
-    constexpr flatten_t flatten{};
+    BOOST_HANA_INLINE_VARIABLE constexpr flatten_t flatten{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_FLATTEN_HPP
diff --git a/boost/hana/fwd/fold.hpp b/boost/hana/fwd/fold.hpp
index e060ab1e1e59ed1b97468095ec3a6a4e490e26d9..f049f4682b9fef28336d58dd19a54d7ba37575e3 100644
--- a/boost/hana/fwd/fold.hpp
+++ b/boost/hana/fwd/fold.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/fold_left.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Equivalent to `fold_left`; provided for convenience.
     //! @ingroup group-Foldable
     //!
@@ -32,7 +32,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! Example
     //! -------
     //! @include example/fold.cpp
-    constexpr auto fold = fold_left;
-BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr auto fold = fold_left;
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_FOLD_HPP
diff --git a/boost/hana/fwd/fold_left.hpp b/boost/hana/fwd/fold_left.hpp
index 22dd22d32fbfac2c3782f306657191c03d8f407e..e45a627e023661e692df2e07d190ec1806f23bff 100644
--- a/boost/hana/fwd/fold_left.hpp
+++ b/boost/hana/fwd/fold_left.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Left-fold of a structure using a binary operation and an optional
     //! initial reduction state.
     //! @ingroup group-Foldable
@@ -81,8 +81,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Xs&& xs, F&& f) const;
     };
 
-    constexpr fold_left_t fold_left{};
+    BOOST_HANA_INLINE_VARIABLE constexpr fold_left_t fold_left{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_FOLD_LEFT_HPP
diff --git a/boost/hana/fwd/fold_right.hpp b/boost/hana/fwd/fold_right.hpp
index a4305e9c7224ede6d402db6495075f0299ae0778..f537163ad5504ed49ed4d16a56f391bdb8dfea21 100644
--- a/boost/hana/fwd/fold_right.hpp
+++ b/boost/hana/fwd/fold_right.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Right-fold of a structure using a binary operation and an optional
     //! initial reduction state.
     //! @ingroup group-Foldable
@@ -85,8 +85,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Xs&& xs, F&& f) const;
     };
 
-    constexpr fold_right_t fold_right{};
+    BOOST_HANA_INLINE_VARIABLE constexpr fold_right_t fold_right{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_FOLD_RIGHT_HPP
diff --git a/boost/hana/fwd/for_each.hpp b/boost/hana/fwd/for_each.hpp
index 83daf25418ca7be72b02924999435fa462cf3f1d..afdeb8db526161343d724d0df5a146349568da58 100644
--- a/boost/hana/fwd/for_each.hpp
+++ b/boost/hana/fwd/for_each.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Perform an action on each element of a foldable, discarding
     //! the result each time.
     //! @ingroup group-Foldable
@@ -48,8 +48,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr void operator()(Xs&& xs, F&& f) const;
     };
 
-    constexpr for_each_t for_each{};
+    BOOST_HANA_INLINE_VARIABLE constexpr for_each_t for_each{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_FOR_EACH_HPP
diff --git a/boost/hana/fwd/front.hpp b/boost/hana/fwd/front.hpp
index 3ac1602ea47c7f3d45cb28d5111bfaf4bfaa4d50..0bdb9c1da34cb940848478c9e53b37a8d602d6ff 100644
--- a/boost/hana/fwd/front.hpp
+++ b/boost/hana/fwd/front.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns the first element of a non-empty iterable.
     //! @ingroup group-Iterable
     //!
@@ -41,8 +41,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Xs&& xs) const;
     };
 
-    constexpr front_t front{};
+    BOOST_HANA_INLINE_VARIABLE constexpr front_t front{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_FRONT_HPP
diff --git a/boost/hana/fwd/fuse.hpp b/boost/hana/fwd/fuse.hpp
index cecc97c73a92d10a39d0a77d6235441d8126d6bb..19fab1730f4f5d6b3e8ab0358b1d481ae58f544d 100644
--- a/boost/hana/fwd/fuse.hpp
+++ b/boost/hana/fwd/fuse.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Transform a function taking multiple arguments into a function that
     //! can be called with a compile-time `Foldable`.
     //! @ingroup group-Foldable
@@ -48,8 +48,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(F&& f) const;
     };
 
-    constexpr fuse_t fuse{};
+    BOOST_HANA_INLINE_VARIABLE constexpr fuse_t fuse{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_FUSE_HPP
diff --git a/boost/hana/fwd/greater.hpp b/boost/hana/fwd/greater.hpp
index 5fcaa4e32d565baa89e6d7c511cbf80265e25f1e..f17f970eebbf82bd0d573b8943682b443fd9ca04 100644
--- a/boost/hana/fwd/greater.hpp
+++ b/boost/hana/fwd/greater.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/nested_than_fwd.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns a `Logical` representing whether `x` is greater than `y`.
     //! @ingroup group-Orderable
     //!
@@ -46,8 +46,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x, Y&& y) const;
     };
 
-    constexpr greater_t greater{};
+    BOOST_HANA_INLINE_VARIABLE constexpr greater_t greater{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_GREATER_HPP
diff --git a/boost/hana/fwd/greater_equal.hpp b/boost/hana/fwd/greater_equal.hpp
index 4b29bfcc96c2264d2020942a6a0a85a10acddd07..e0a0e3eb87cffc71871544eeafb029773b5723f3 100644
--- a/boost/hana/fwd/greater_equal.hpp
+++ b/boost/hana/fwd/greater_equal.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/nested_than_fwd.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns a `Logical` representing whether `x` is greater than or
     //! equal to `y`.
     //! @ingroup group-Orderable
@@ -47,8 +47,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x, Y&& y) const;
     };
 
-    constexpr greater_equal_t greater_equal{};
+    BOOST_HANA_INLINE_VARIABLE constexpr greater_equal_t greater_equal{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_GREATER_EQUAL_HPP
diff --git a/boost/hana/fwd/group.hpp b/boost/hana/fwd/group.hpp
index 1be1bee38604aff762661d5f332b4d95ab7b14d8..d2700f51de43a8debab84a65f437481b1594c0ab 100644
--- a/boost/hana/fwd/group.hpp
+++ b/boost/hana/fwd/group.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/nested_by_fwd.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Group adjacent elements of a sequence that all respect a binary
     //! predicate, by default equality.
     //! @ingroup group-Sequence
@@ -96,8 +96,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Predicate&& pred) const;
     };
 
-    constexpr group_t group{};
+    BOOST_HANA_INLINE_VARIABLE constexpr group_t group{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_GROUP_HPP
diff --git a/boost/hana/fwd/hash.hpp b/boost/hana/fwd/hash.hpp
index 38602db518b63257b758a47f8c095acc379a306b..51656ee57ab878da68d0f12b82db10b4f664d98c 100644
--- a/boost/hana/fwd/hash.hpp
+++ b/boost/hana/fwd/hash.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns a `hana::type` representing the compile-time hash of an object.
     //! @ingroup group-Hashable
     //!
@@ -61,8 +61,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(X const& x) const;
     };
 
-    constexpr hash_t hash{};
+    BOOST_HANA_INLINE_VARIABLE constexpr hash_t hash{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_HASH_HPP
diff --git a/boost/hana/fwd/if.hpp b/boost/hana/fwd/if.hpp
index 59b61975f85c999adda3331c299966331ac203f3..6a8deee2fc09df9a262c15273385fe4dbe825450 100644
--- a/boost/hana/fwd/if.hpp
+++ b/boost/hana/fwd/if.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Conditionally return one of two values based on a condition.
     //! @ingroup group-Logical
     //!
@@ -50,8 +50,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Cond&& cond, Then&& then, Else&& else_) const;
     };
 
-    constexpr if_t if_{};
+    BOOST_HANA_INLINE_VARIABLE constexpr if_t if_{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_IF_HPP
diff --git a/boost/hana/fwd/index_if.hpp b/boost/hana/fwd/index_if.hpp
index 59f98f59faefc688bf06b72d9bd15a17ea4e1490..3283acab56d003dde3c687ebe59873a81b04a874 100644
--- a/boost/hana/fwd/index_if.hpp
+++ b/boost/hana/fwd/index_if.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Finds the value associated to the first key satisfying a predicate.
     //! @ingroup group-Iterable
     //!
@@ -52,9 +52,9 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred&& pred) const;
     };
 
-    constexpr index_if_t index_if{};
+    BOOST_HANA_INLINE_VARIABLE constexpr index_if_t index_if{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_INDEX_IF_HPP
 
diff --git a/boost/hana/fwd/insert.hpp b/boost/hana/fwd/insert.hpp
index 3ca9aa458d2224c97a4855321498c44d25b0d89e..dac614cec7e0be8e23f40ec87ea8c72028b68e1d 100644
--- a/boost/hana/fwd/insert.hpp
+++ b/boost/hana/fwd/insert.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     // Note: This function is documented per datatype/concept only.
     //! @cond
     template <typename T, typename = void>
@@ -26,7 +26,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Set&& set, Args&& ...args) const;
     };
 
-    constexpr insert_t insert{};
+    BOOST_HANA_INLINE_VARIABLE constexpr insert_t insert{};
 
 
     //! Insert a value at a given index in a sequence.
@@ -55,6 +55,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         return tag-dispatched;
     };
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_INSERT_HPP
diff --git a/boost/hana/fwd/insert_range.hpp b/boost/hana/fwd/insert_range.hpp
index 88b6d98acd74f833610aff2d180d020401af1532..e42b2476b4a1e82fc6e377a5115b0960fbe15cc3 100644
--- a/boost/hana/fwd/insert_range.hpp
+++ b/boost/hana/fwd/insert_range.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Insert several values at a given index in a sequence.
     //! @ingroup group-Sequence
     //!
@@ -50,8 +50,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, N&& n, Elements&& elements) const;
     };
 
-    constexpr insert_range_t insert_range{};
+    BOOST_HANA_INLINE_VARIABLE constexpr insert_range_t insert_range{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_INSERT_RANGE_HPP
diff --git a/boost/hana/fwd/integral_constant.hpp b/boost/hana/fwd/integral_constant.hpp
index 6ef1272d80e8fd85ee04a1d9ef2e9c23a671e9a8..4cc3485adc5682b1f727c43948e862030183a979 100644
--- a/boost/hana/fwd/integral_constant.hpp
+++ b/boost/hana/fwd/integral_constant.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Creates an `integral_constant` holding the given compile-time value.
     //! @relates hana::integral_constant
     //!
@@ -36,7 +36,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! -------
     //! @snippet example/integral_constant.cpp integral_c
     template <typename T, T v>
-    constexpr integral_constant<T, v> integral_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr integral_constant<T, v> integral_c{};
 
 
     //! @relates hana::integral_constant
@@ -45,19 +45,19 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! @relates hana::integral_constant
     template <bool b>
-    constexpr bool_<b> bool_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr bool_<b> bool_c{};
 
     //! @relates hana::integral_constant
     using true_ = bool_<true>;
 
     //! @relates hana::integral_constant
-    constexpr auto true_c = bool_c<true>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto true_c = bool_c<true>;
 
     //! @relates hana::integral_constant
     using false_ = bool_<false>;
 
     //! @relates hana::integral_constant
-    constexpr auto false_c = bool_c<false>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto false_c = bool_c<false>;
 
 
     //! @relates hana::integral_constant
@@ -66,7 +66,7 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! @relates hana::integral_constant
     template <char c>
-    constexpr char_<c> char_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr char_<c> char_c{};
 
 
     //! @relates hana::integral_constant
@@ -75,7 +75,7 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! @relates hana::integral_constant
     template <short i>
-    constexpr short_<i> short_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr short_<i> short_c{};
 
 
     //! @relates hana::integral_constant
@@ -84,7 +84,7 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! @relates hana::integral_constant
     template <unsigned short i>
-    constexpr ushort_<i> ushort_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr ushort_<i> ushort_c{};
 
 
     //! @relates hana::integral_constant
@@ -93,7 +93,7 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! @relates hana::integral_constant
     template <int i>
-    constexpr int_<i> int_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr int_<i> int_c{};
 
 
     //! @relates hana::integral_constant
@@ -102,7 +102,7 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! @relates hana::integral_constant
     template <unsigned int i>
-    constexpr uint<i> uint_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr uint<i> uint_c{};
 
 
     //! @relates hana::integral_constant
@@ -111,7 +111,7 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! @relates hana::integral_constant
     template <long i>
-    constexpr long_<i> long_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr long_<i> long_c{};
 
 
     //! @relates hana::integral_constant
@@ -120,7 +120,7 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! @relates hana::integral_constant
     template <unsigned long i>
-    constexpr ulong<i> ulong_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr ulong<i> ulong_c{};
 
 
     //! @relates hana::integral_constant
@@ -129,7 +129,7 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! @relates hana::integral_constant
     template <long long i>
-    constexpr llong<i> llong_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr llong<i> llong_c{};
 
 
     //! @relates hana::integral_constant
@@ -138,7 +138,7 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! @relates hana::integral_constant
     template <unsigned long long i>
-    constexpr ullong<i> ullong_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr ullong<i> ullong_c{};
 
 
     //! @relates hana::integral_constant
@@ -147,7 +147,7 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! @relates hana::integral_constant
     template <std::size_t i>
-    constexpr size_t<i> size_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr size_t<i> size_c{};
 
 
     namespace literals {
@@ -170,6 +170,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         template <char ...c>
         constexpr auto operator"" _c();
     }
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_INTEGRAL_CONSTANT_HPP
diff --git a/boost/hana/fwd/intersection.hpp b/boost/hana/fwd/intersection.hpp
index f289dd03fa2f45779a4e8c9d06e6a91c28e5d4e8..859d33e58f762509e71d5936a141145179e2b722 100644
--- a/boost/hana/fwd/intersection.hpp
+++ b/boost/hana/fwd/intersection.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     // Note: This function is documented per datatype/concept only.
     //! @cond
     template <typename S, typename = void>
@@ -26,7 +26,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&&, Ys&&) const;
     };
 
-    constexpr intersection_t intersection{};
-BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr intersection_t intersection{};
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_INTERSECTION_HPP
diff --git a/boost/hana/fwd/intersperse.hpp b/boost/hana/fwd/intersperse.hpp
index 35e8a725b58844616677602467793e96a929d3a1..2cae4de4603bfdfbeddeab9a074105ec9041fbc4 100644
--- a/boost/hana/fwd/intersperse.hpp
+++ b/boost/hana/fwd/intersperse.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Insert a value between each pair of elements in a finite sequence.
     //! @ingroup group-Sequence
     //!
@@ -50,8 +50,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Z&& z) const;
     };
 
-    constexpr intersperse_t intersperse{};
+    BOOST_HANA_INLINE_VARIABLE constexpr intersperse_t intersperse{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_INTERSPERSE_HPP
diff --git a/boost/hana/fwd/is_disjoint.hpp b/boost/hana/fwd/is_disjoint.hpp
index 8a3520b5580928b497dd2663924880d5702fe80e..37206bb8f880a514caa09a782c4f61d2595f5518 100644
--- a/boost/hana/fwd/is_disjoint.hpp
+++ b/boost/hana/fwd/is_disjoint.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns whether two `Searchable`s are disjoint.
     //! @ingroup group-Searchable
     //!
@@ -43,8 +43,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Ys&& ys) const;
     };
 
-    constexpr is_disjoint_t is_disjoint{};
+    BOOST_HANA_INLINE_VARIABLE constexpr is_disjoint_t is_disjoint{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_IS_DISJOINT_HPP
diff --git a/boost/hana/fwd/is_empty.hpp b/boost/hana/fwd/is_empty.hpp
index a33dc5af8c61c21a8f804a79d17d309f8d76b407..88e4b7365e9777dee73ca372a1d26a89b545af60 100644
--- a/boost/hana/fwd/is_empty.hpp
+++ b/boost/hana/fwd/is_empty.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns whether the iterable is empty.
     //! @ingroup group-Iterable
     //!
@@ -42,8 +42,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs const& xs) const;
     };
 
-    constexpr is_empty_t is_empty{};
+    BOOST_HANA_INLINE_VARIABLE constexpr is_empty_t is_empty{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_IS_EMPTY_HPP
diff --git a/boost/hana/fwd/is_subset.hpp b/boost/hana/fwd/is_subset.hpp
index aceb85aa86142f0106bec0037e4fb1f4d748c94f..1429f7cc083757c340cc4b6f14028618b0f4b6bf 100644
--- a/boost/hana/fwd/is_subset.hpp
+++ b/boost/hana/fwd/is_subset.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/infix.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns whether a structure contains a subset of the keys of
     //! another structure.
     //! @ingroup group-Searchable
@@ -72,8 +72,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Ys&& ys) const;
     };
 
-    constexpr auto is_subset = hana::infix(is_subset_t{});
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_subset = hana::infix(is_subset_t{});
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_IS_SUBSET_HPP
diff --git a/boost/hana/fwd/keys.hpp b/boost/hana/fwd/keys.hpp
index 24c93b749aea6a24b1a151eb5bc82145ec5cf541..997be12d354ff306101289d6c182310f31080087 100644
--- a/boost/hana/fwd/keys.hpp
+++ b/boost/hana/fwd/keys.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     // Note: This function is documented per datatype/concept only.
     //! @cond
     template <typename T, typename = void>
@@ -26,7 +26,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Map&& map) const;
     };
 
-    constexpr keys_t keys{};
+    BOOST_HANA_INLINE_VARIABLE constexpr keys_t keys{};
 
     //! Returns a `Sequence` containing the name of the members of
     //! the data structure.
@@ -45,6 +45,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         return implementation_defined;
     };
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_KEYS_HPP
diff --git a/boost/hana/fwd/lazy.hpp b/boost/hana/fwd/lazy.hpp
index 7568e8e4a6e7239182ad83ff1ffcd5a0e42f0403..e0afc62baa38eff9e4aa66a50be40358ee46eb62 100644
--- a/boost/hana/fwd/lazy.hpp
+++ b/boost/hana/fwd/lazy.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/core/make.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-datatypes
     //! `hana::lazy` implements superficial laziness via a monadic interface.
     //!
@@ -118,7 +118,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! Example
     //! -------
     //! @include example/lazy/make.cpp
-    constexpr auto make_lazy = make<lazy_tag>;
-BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr auto make_lazy = make<lazy_tag>;
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_LAZY_HPP
diff --git a/boost/hana/fwd/length.hpp b/boost/hana/fwd/length.hpp
index 331b1d93d2212253cf485470245203e76db00d4c..5415a32e74ec3739175ac5f5c02335ce8b3fa747 100644
--- a/boost/hana/fwd/length.hpp
+++ b/boost/hana/fwd/length.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Return the number of elements in a foldable structure.
     //! @ingroup group-Foldable
     //!
@@ -43,8 +43,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs const& xs) const;
     };
 
-    constexpr length_t length{};
+    BOOST_HANA_INLINE_VARIABLE constexpr length_t length{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_LENGTH_HPP
diff --git a/boost/hana/fwd/less.hpp b/boost/hana/fwd/less.hpp
index f1695b2b74c445a53e69ff2fa6c34c5bd78a63b8..d59052fcf2e40cf0a07c918ef656fb988865bb54 100644
--- a/boost/hana/fwd/less.hpp
+++ b/boost/hana/fwd/less.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/nested_than_fwd.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns a `Logical` representing whether `x` is less than `y`.
     //! @ingroup group-Orderable
     //!
@@ -46,8 +46,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(X&& x, Y&& y) const;
     };
 
-    constexpr less_t less{};
+    BOOST_HANA_INLINE_VARIABLE constexpr less_t less{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_LESS_HPP
diff --git a/boost/hana/fwd/less_equal.hpp b/boost/hana/fwd/less_equal.hpp
index e5c66e4bc3dd5138578e044048a6e37c0e3abe44..350382f68cf7fbab652ed87981d65923174a83d8 100644
--- a/boost/hana/fwd/less_equal.hpp
+++ b/boost/hana/fwd/less_equal.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/nested_than_fwd.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns a `Logical` representing whether `x` is less than or
     //! equal to `y`.
     //! @ingroup group-Orderable
@@ -47,8 +47,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(X&& x, Y&& y) const;
     };
 
-    constexpr less_equal_t less_equal{};
+    BOOST_HANA_INLINE_VARIABLE constexpr less_equal_t less_equal{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_LESS_EQUAL_HPP
diff --git a/boost/hana/fwd/lexicographical_compare.hpp b/boost/hana/fwd/lexicographical_compare.hpp
index a95aac52128e52438ec07fab169ed6664a19a715..ca290b04bfe13be1587cfbd9e06715118a74ded8 100644
--- a/boost/hana/fwd/lexicographical_compare.hpp
+++ b/boost/hana/fwd/lexicographical_compare.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Short-circuiting lexicographical comparison of two `Iterable`s with
     //! an optional custom predicate, by default `hana::less`.
     //! @ingroup group-Iterable
@@ -86,8 +86,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs const& xs, Ys const& ys, Pred const& pred) const;
     };
 
-    constexpr lexicographical_compare_t lexicographical_compare{};
+    BOOST_HANA_INLINE_VARIABLE constexpr lexicographical_compare_t lexicographical_compare{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_LEXICOGRAPHICAL_COMPARE_HPP
diff --git a/boost/hana/fwd/lift.hpp b/boost/hana/fwd/lift.hpp
index 2d4ac6cc13a001c22c7ab914177f014f6c1940a3..c8398c2852e8e23f0161db2122612e2aacf7d3c0 100644
--- a/boost/hana/fwd/lift.hpp
+++ b/boost/hana/fwd/lift.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Lift a value into an `Applicative` structure.
     //! @ingroup group-Applicative
     //!
@@ -55,8 +55,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <typename A>
-    constexpr lift_t<A> lift{};
+    BOOST_HANA_INLINE_VARIABLE constexpr lift_t<A> lift{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_LIFT_HPP
diff --git a/boost/hana/fwd/map.hpp b/boost/hana/fwd/map.hpp
index 782b0f1e970e1ff8d14480f663ee79bc8d0bcd10..0d54638c698bb1add176e0df66c0735163ba9025 100644
--- a/boost/hana/fwd/map.hpp
+++ b/boost/hana/fwd/map.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/keys.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Tag representing `hana::map`s.
     //! @relates hana::map
     struct map_tag { };
@@ -169,11 +169,11 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! Example
     //! -------
     //! @include example/map/make.cpp
-    constexpr auto make_map = make<map_tag>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto make_map = make<map_tag>;
 
     //! Equivalent to `to<map_tag>`; provided for convenience.
     //! @relates hana::map
-    constexpr auto to_map = to<map_tag>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto to_map = to<map_tag>;
 
     //! Returns a `Sequence` of the keys of the map, in unspecified order.
     //! @relates hana::map
@@ -205,7 +205,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Map&& map) const;
     };
 
-    constexpr values_t values{};
+    BOOST_HANA_INLINE_VARIABLE constexpr values_t values{};
 #endif
 
     //! Inserts a new key/value pair in a map.
@@ -377,6 +377,6 @@ constexpr auto symmetric_difference = [](auto&& xs, auto&& ys) {
 #endif
 
 
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_MAP_HPP
diff --git a/boost/hana/fwd/max.hpp b/boost/hana/fwd/max.hpp
index e34d558e25f7c6fde83ce201e065bddbfe54b28d..c613c677a9258336b3d80358632ad9198424f4d1 100644
--- a/boost/hana/fwd/max.hpp
+++ b/boost/hana/fwd/max.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns the greatest of its arguments according to the `less` ordering.
     //! @ingroup group-Orderable
     //!
@@ -37,8 +37,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x, Y&& y) const;
     };
 
-    constexpr max_t max{};
+    BOOST_HANA_INLINE_VARIABLE constexpr max_t max{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_MAX_HPP
diff --git a/boost/hana/fwd/maximum.hpp b/boost/hana/fwd/maximum.hpp
index 9a49e83d405104c6ad66e39df6133b27d9de044e..e1f99a92511dfe7aa5f7e4272931782806ec4950 100644
--- a/boost/hana/fwd/maximum.hpp
+++ b/boost/hana/fwd/maximum.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/nested_by_fwd.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Return the greatest element of a non-empty structure with respect to
     //! a `predicate`, by default `less`.
     //! @ingroup group-Foldable
@@ -109,8 +109,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Xs&& xs, Predicate&& pred) const;
     };
 
-    constexpr maximum_t maximum{};
+    BOOST_HANA_INLINE_VARIABLE constexpr maximum_t maximum{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_MAXIMUM_HPP
diff --git a/boost/hana/fwd/members.hpp b/boost/hana/fwd/members.hpp
index a9f2d82bfb9cae8a037a22f898ac81cc7606554d..fef229ca1e25ff793b378f91c5bc817e84b206a2 100644
--- a/boost/hana/fwd/members.hpp
+++ b/boost/hana/fwd/members.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns a `Sequence` containing the members of a `Struct`.
     //! @ingroup group-Struct
     //!
@@ -39,8 +39,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Object&& object) const;
     };
 
-    constexpr members_t members{};
+    BOOST_HANA_INLINE_VARIABLE constexpr members_t members{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_MEMBERS_HPP
diff --git a/boost/hana/fwd/min.hpp b/boost/hana/fwd/min.hpp
index 349787b5714d928ba738975f121910545e64a12c..2b20dac49fd584ed76d561fadf5cbe52d2abe482 100644
--- a/boost/hana/fwd/min.hpp
+++ b/boost/hana/fwd/min.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns the smallest of its arguments according to the `less` ordering.
     //! @ingroup group-Orderable
     //!
@@ -44,8 +44,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x, Y&& y) const;
     };
 
-    constexpr min_t min{};
+    BOOST_HANA_INLINE_VARIABLE constexpr min_t min{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_MIN_HPP
diff --git a/boost/hana/fwd/minimum.hpp b/boost/hana/fwd/minimum.hpp
index df80196bc625620501512670c0bd1a0919310499..f6109cfcb0c3db990586b90acafe51669a13965e 100644
--- a/boost/hana/fwd/minimum.hpp
+++ b/boost/hana/fwd/minimum.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/nested_by_fwd.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Return the least element of a non-empty structure with respect to
     //! a `predicate`, by default `less`.
     //! @ingroup group-Foldable
@@ -109,8 +109,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Xs&& xs, Predicate&& pred) const;
     };
 
-    constexpr minimum_t minimum{};
+    BOOST_HANA_INLINE_VARIABLE constexpr minimum_t minimum{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_MINIMUM_HPP
diff --git a/boost/hana/fwd/minus.hpp b/boost/hana/fwd/minus.hpp
index 3b3b3ff428910b849bf7f08ad581fb11356a6590..b0fa19aa8822aad33c94da6b7aaa8a1b06934eba 100644
--- a/boost/hana/fwd/minus.hpp
+++ b/boost/hana/fwd/minus.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Subtract two elements of a group.
     //! @ingroup group-Group
     //!
@@ -60,8 +60,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x, Y&& y) const;
     };
 
-    constexpr minus_t minus{};
+    BOOST_HANA_INLINE_VARIABLE constexpr minus_t minus{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_MINUS_HPP
diff --git a/boost/hana/fwd/mod.hpp b/boost/hana/fwd/mod.hpp
index c0872803fcf7c126be85efe0da6dfd06dd6550c6..dd475d84a6108e23d65d782e18e9ac3dc873b1f4 100644
--- a/boost/hana/fwd/mod.hpp
+++ b/boost/hana/fwd/mod.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Generalized integer modulus.
     //! @ingroup group-EuclideanRing
     //!
@@ -55,8 +55,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x, Y&& y) const;
     };
 
-    constexpr mod_t mod{};
+    BOOST_HANA_INLINE_VARIABLE constexpr mod_t mod{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_MOD_HPP
diff --git a/boost/hana/fwd/monadic_compose.hpp b/boost/hana/fwd/monadic_compose.hpp
index e9adde1bc27a3b5d665e4fa37e7c5e0a5c1ef4b1..bcf44b7633ce375a322a1a21639cbff874efc96f 100644
--- a/boost/hana/fwd/monadic_compose.hpp
+++ b/boost/hana/fwd/monadic_compose.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Composition of monadic functions.
     //! @ingroup group-Monad
     //!
@@ -68,8 +68,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(F&& f, G&& g) const;
     };
 
-    constexpr monadic_compose_t monadic_compose{};
+    BOOST_HANA_INLINE_VARIABLE constexpr monadic_compose_t monadic_compose{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_MONADIC_COMPOSE_HPP
diff --git a/boost/hana/fwd/monadic_fold_left.hpp b/boost/hana/fwd/monadic_fold_left.hpp
index aa66097b3e3703e612390abc3bf4289ce2f577aa..8a4c03b96994fbb60a20334ff9dab66df2be0482 100644
--- a/boost/hana/fwd/monadic_fold_left.hpp
+++ b/boost/hana/fwd/monadic_fold_left.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Monadic left-fold of a structure with a binary operation and an
     //! optional initial reduction state.
     //! @ingroup group-Foldable
@@ -103,8 +103,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <typename M>
-    constexpr monadic_fold_left_t<M> monadic_fold_left{};
+    BOOST_HANA_INLINE_VARIABLE constexpr monadic_fold_left_t<M> monadic_fold_left{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_MONADIC_FOLD_LEFT_HPP
diff --git a/boost/hana/fwd/monadic_fold_right.hpp b/boost/hana/fwd/monadic_fold_right.hpp
index fff6fc0c1fdc54e589733c318517bd41007e85d1..946288ff4026072f00d0a2550fd6a845d436a205 100644
--- a/boost/hana/fwd/monadic_fold_right.hpp
+++ b/boost/hana/fwd/monadic_fold_right.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Monadic right-fold of a structure with a binary operation and an
     //! optional initial reduction state.
     //! @ingroup group-Foldable
@@ -105,8 +105,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <typename M>
-    constexpr monadic_fold_right_t<M> monadic_fold_right{};
+    BOOST_HANA_INLINE_VARIABLE constexpr monadic_fold_right_t<M> monadic_fold_right{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_MONADIC_FOLD_RIGHT_HPP
diff --git a/boost/hana/fwd/mult.hpp b/boost/hana/fwd/mult.hpp
index d322071d9cfd41ea2c1ab16c24da543e7bdcc844..c7e825be2f45d188f06f2cb1b28cc78f9cd7d1ae 100644
--- a/boost/hana/fwd/mult.hpp
+++ b/boost/hana/fwd/mult.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Associative operation of a `Ring`.
     //! @ingroup group-Ring
     //!
@@ -56,8 +56,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x, Y&& y) const;
     };
 
-    constexpr mult_t mult{};
+    BOOST_HANA_INLINE_VARIABLE constexpr mult_t mult{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_MULT_HPP
diff --git a/boost/hana/fwd/negate.hpp b/boost/hana/fwd/negate.hpp
index 6c4f70da8d5649258cb536adcf972fb503851f9f..e26b40f637d884d78f93b2e478034ea62860753b 100644
--- a/boost/hana/fwd/negate.hpp
+++ b/boost/hana/fwd/negate.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Return the inverse of an element of a group.
     //! @ingroup group-Group
     //!
@@ -35,8 +35,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x) const;
     };
 
-    constexpr negate_t negate{};
+    BOOST_HANA_INLINE_VARIABLE constexpr negate_t negate{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_NEGATE_HPP
diff --git a/boost/hana/fwd/none.hpp b/boost/hana/fwd/none.hpp
index d0d2da94a911a9bce5511cfa2cde2bd17a405870..7bce9f03d4ff95e829bbdbdef200ffee70245be2 100644
--- a/boost/hana/fwd/none.hpp
+++ b/boost/hana/fwd/none.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns whether all of the keys of the structure are false-valued.
     //! @ingroup group-Searchable
     //!
@@ -39,8 +39,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs) const;
     };
 
-    constexpr none_t none{};
+    BOOST_HANA_INLINE_VARIABLE constexpr none_t none{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_NONE_HPP
diff --git a/boost/hana/fwd/none_of.hpp b/boost/hana/fwd/none_of.hpp
index 3e57cf1d65771ff57a77d90e2251239c5561f21d..7c12e20d7cf84167040481625c52f8f257b9abf3 100644
--- a/boost/hana/fwd/none_of.hpp
+++ b/boost/hana/fwd/none_of.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns whether none of the keys of the structure satisfy the
     //! `predicate`.
     //! @ingroup group-Searchable
@@ -48,8 +48,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred&& pred) const;
     };
 
-    constexpr none_of_t none_of{};
+    BOOST_HANA_INLINE_VARIABLE constexpr none_of_t none_of{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_NONE_OF_HPP
diff --git a/boost/hana/fwd/not.hpp b/boost/hana/fwd/not.hpp
index 08d19d2bd5e5ea599743284289ec05b2565d12f6..d81d93468f138b97d389204774eefb19446e508b 100644
--- a/boost/hana/fwd/not.hpp
+++ b/boost/hana/fwd/not.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Negates a `Logical`.
     //! @ingroup group-Logical
     //!
@@ -40,8 +40,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x) const;
     };
 
-    constexpr not_t not_{};
+    BOOST_HANA_INLINE_VARIABLE constexpr not_t not_{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_NOT_HPP
diff --git a/boost/hana/fwd/not_equal.hpp b/boost/hana/fwd/not_equal.hpp
index 7063a3796c80f3ef2c1d80a5edd87a14d7fcf677..0ee15137409c54dc7cef5f491ffac23c6c5f548c 100644
--- a/boost/hana/fwd/not_equal.hpp
+++ b/boost/hana/fwd/not_equal.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/nested_to_fwd.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns a `Logical` representing whether `x` is not equal to `y`.
     //! @ingroup group-Comparable
     //!
@@ -63,8 +63,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(X&& x, Y&& y) const;
     };
 
-    constexpr not_equal_t not_equal{};
+    BOOST_HANA_INLINE_VARIABLE constexpr not_equal_t not_equal{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_NOT_EQUAL_HPP
diff --git a/boost/hana/fwd/one.hpp b/boost/hana/fwd/one.hpp
index 27d4f37bd68981e8413e57c210fb695659af19d8..7d7e502da94ed219dcdbf0a14ac69c9b5c5c7f75 100644
--- a/boost/hana/fwd/one.hpp
+++ b/boost/hana/fwd/one.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Identity of the `Ring` multiplication.
     //! @ingroup group-Ring
     //!
@@ -40,8 +40,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <typename R>
-    constexpr one_t<R> one{};
+    BOOST_HANA_INLINE_VARIABLE constexpr one_t<R> one{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ONE_HPP
diff --git a/boost/hana/fwd/optional.hpp b/boost/hana/fwd/optional.hpp
index 8a348a8b12b7167e0cc36e4358d32e2364519d59..c02c5f84ede047d3deff275e1c310eaded6b17ef 100644
--- a/boost/hana/fwd/optional.hpp
+++ b/boost/hana/fwd/optional.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/core/make.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-datatypes
     //! Optional value whose optional-ness is known at compile-time.
     //!
@@ -310,7 +310,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! Example
     //! -------
     //! @include example/optional/make.cpp
-    constexpr auto make_optional = make<optional_tag>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto make_optional = make<optional_tag>;
 
     //! Create an optional value containing `x`.
     //! @relates hana::optional
@@ -329,7 +329,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(T&&) const;
     };
 
-    constexpr make_just_t just{};
+    BOOST_HANA_INLINE_VARIABLE constexpr make_just_t just{};
 #endif
 
     //! An empty optional value.
@@ -366,7 +366,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr U&& value_or(U&& u) const;
     };
 
-    constexpr optional<> nothing{};
+    BOOST_HANA_INLINE_VARIABLE constexpr optional<> nothing{};
 #endif
 
     //! Apply a function to the contents of an optional, with a fallback
@@ -421,7 +421,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         { return static_cast<Def&&>(def); }
     };
 
-    constexpr maybe_t maybe{};
+    BOOST_HANA_INLINE_VARIABLE constexpr maybe_t maybe{};
 #endif
 
     //! Calls a function if the call expression is well-formed.
@@ -462,7 +462,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(F&& f) const;
     };
 
-    constexpr sfinae_t sfinae{};
+    BOOST_HANA_INLINE_VARIABLE constexpr sfinae_t sfinae{};
 #endif
 
     //! Return whether an `optional` contains a value.
@@ -485,7 +485,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(optional<T...> const&) const;
     };
 
-    constexpr is_just_t is_just{};
+    BOOST_HANA_INLINE_VARIABLE constexpr is_just_t is_just{};
 #endif
 
     //! Return whether an `optional` is empty.
@@ -508,8 +508,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(optional<T...> const&) const;
     };
 
-    constexpr is_nothing_t is_nothing{};
+    BOOST_HANA_INLINE_VARIABLE constexpr is_nothing_t is_nothing{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_OPTIONAL_HPP
diff --git a/boost/hana/fwd/or.hpp b/boost/hana/fwd/or.hpp
index c14efc8e3488a60b1fd18ec3b1e4a4393aa836da..1fa2a8497611dde69fca42e3275d539880e4c934 100644
--- a/boost/hana/fwd/or.hpp
+++ b/boost/hana/fwd/or.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Return whether any of the arguments is true-valued.
     //! @ingroup group-Logical
     //!
@@ -46,8 +46,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x, Y&& ...y) const;
     };
 
-    constexpr or_t or_{};
+    BOOST_HANA_INLINE_VARIABLE constexpr or_t or_{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_OR_HPP
diff --git a/boost/hana/fwd/ordering.hpp b/boost/hana/fwd/ordering.hpp
index 78c9e2c3b87c52c07b516e050ed0413b77289f39..217fbab5fdc0fad2e0b3190ba6755c9c5ff8c484 100644
--- a/boost/hana/fwd/ordering.hpp
+++ b/boost/hana/fwd/ordering.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns a function performing `less` after applying a transformation
     //! to both arguments.
     //! @ingroup group-Orderable
@@ -58,8 +58,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(F&& f) const;
     };
 
-    constexpr ordering_t ordering{};
+    BOOST_HANA_INLINE_VARIABLE constexpr ordering_t ordering{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ORDERING_HPP
diff --git a/boost/hana/fwd/pair.hpp b/boost/hana/fwd/pair.hpp
index 1ce0e2277244950fb1117292d136b9046129cac8..d8344ad86a6bd3ffd2e2ef8d06612982764d9ffb 100644
--- a/boost/hana/fwd/pair.hpp
+++ b/boost/hana/fwd/pair.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/core/make.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-datatypes
     //! Generic container for two elements.
     //!
@@ -152,7 +152,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! Example
     //! -------
     //! @include example/pair/make.cpp
-    constexpr auto make_pair = make<pair_tag>;
-BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr auto make_pair = make<pair_tag>;
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_PAIR_HPP
diff --git a/boost/hana/fwd/partition.hpp b/boost/hana/fwd/partition.hpp
index b7a7d3a2ae37d828e564a516b78567c416fa7afa..ab83f8499665c2485cae9c118282ccf35fef3ead 100644
--- a/boost/hana/fwd/partition.hpp
+++ b/boost/hana/fwd/partition.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Partition a sequence based on a `predicate`.
     //! @ingroup group-Sequence
     //!
@@ -74,8 +74,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred&& pred) const;
     };
 
-    constexpr partition_t partition{};
+    BOOST_HANA_INLINE_VARIABLE constexpr partition_t partition{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_PARTITION_HPP
diff --git a/boost/hana/fwd/permutations.hpp b/boost/hana/fwd/permutations.hpp
index 7aeb27b2e8bcc2c2475fa1deacb3fac77c612a3b..dd1d80509f26385f448834f866f68b51ce537d00 100644
--- a/boost/hana/fwd/permutations.hpp
+++ b/boost/hana/fwd/permutations.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Return a sequence of all the permutations of the given sequence.
     //! @ingroup group-Sequence
     //!
@@ -43,8 +43,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs) const;
     };
 
-    constexpr permutations_t permutations{};
+    BOOST_HANA_INLINE_VARIABLE constexpr permutations_t permutations{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_PERMUTATIONS_HPP
diff --git a/boost/hana/fwd/plus.hpp b/boost/hana/fwd/plus.hpp
index 6d6cac82e28ae70214451a71ede2c2d1e6328e16..e00ac06d115bf4827de98c0c2c4227f2334cf431 100644
--- a/boost/hana/fwd/plus.hpp
+++ b/boost/hana/fwd/plus.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Associative binary operation on a `Monoid`.
     //! @ingroup group-Monoid
     //!
@@ -56,8 +56,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x, Y&& y) const;
     };
 
-    constexpr plus_t plus{};
+    BOOST_HANA_INLINE_VARIABLE constexpr plus_t plus{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_PLUS_HPP
diff --git a/boost/hana/fwd/power.hpp b/boost/hana/fwd/power.hpp
index c94b841194a5b61fd87d11e4c967a2871c23ccb8..18fc160baec4033534b1e29ee75602c89974b1e6 100644
--- a/boost/hana/fwd/power.hpp
+++ b/boost/hana/fwd/power.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Elevate a ring element to its `n`th power.
     //! @ingroup group-Ring
     //!
@@ -49,8 +49,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(X&& x, N const& n) const;
     };
 
-    constexpr power_t power{};
+    BOOST_HANA_INLINE_VARIABLE constexpr power_t power{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_POWER_HPP
diff --git a/boost/hana/fwd/prefix.hpp b/boost/hana/fwd/prefix.hpp
index 78592e11f22201413fb631ea13c4a4d09011df1c..1f87735d69b8280083366dcc852fb65a94a59b78 100644
--- a/boost/hana/fwd/prefix.hpp
+++ b/boost/hana/fwd/prefix.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Inserts a value before each element of a monadic structure.
     //! @ingroup group-MonadPlus
     //!
@@ -65,8 +65,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pref&& pref) const;
     };
 
-    constexpr prefix_t prefix{};
+    BOOST_HANA_INLINE_VARIABLE constexpr prefix_t prefix{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_PREFIX_HPP
diff --git a/boost/hana/fwd/prepend.hpp b/boost/hana/fwd/prepend.hpp
index 8bb44ea2db09a9a00b6907d8b22d8c1eaca76264..d21adeb757ba18a7beab193d45c89d9b5e34aa52 100644
--- a/boost/hana/fwd/prepend.hpp
+++ b/boost/hana/fwd/prepend.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Prepend an element to a monadic structure.
     //! @ingroup group-MonadPlus
     //!
@@ -66,8 +66,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, X&& x) const;
     };
 
-    constexpr prepend_t prepend{};
+    BOOST_HANA_INLINE_VARIABLE constexpr prepend_t prepend{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_PREPEND_HPP
diff --git a/boost/hana/fwd/product.hpp b/boost/hana/fwd/product.hpp
index ff545ceacbbb996c6b5e4a1ddacd147bc8cc1a61..68c4a39330a69314f781067ed50e30ab3d6fd2f6 100644
--- a/boost/hana/fwd/product.hpp
+++ b/boost/hana/fwd/product.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/integral_constant.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Compute the product of the numbers of a structure.
     //! @ingroup group-Foldable
     //!
@@ -66,8 +66,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <typename R = integral_constant_tag<int>>
-    constexpr product_t<R> product{};
+    BOOST_HANA_INLINE_VARIABLE constexpr product_t<R> product{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_PRODUCT_HPP
diff --git a/boost/hana/fwd/range.hpp b/boost/hana/fwd/range.hpp
index 3fb2a939dc4e79344faa9b6f8015a80832e5ffa0..c602fc943faba8cba577aa6788c2fd879ed90491 100644
--- a/boost/hana/fwd/range.hpp
+++ b/boost/hana/fwd/range.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/integral_constant.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
 #ifdef BOOST_HANA_DOXYGEN_INVOKED
     //! @ingroup group-datatypes
     //! Compile-time half-open interval of `hana::integral_constant`s.
@@ -112,7 +112,7 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! Alias to `make<range_tag>`; provided for convenience.
     //! @relates hana::range
-    constexpr auto make_range = make<range_tag>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto make_range = make<range_tag>;
 
     //! Shorthand to create a `hana::range` with the given bounds.
     //! @relates hana::range
@@ -143,8 +143,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     constexpr auto range_c = make_range(integral_c<T, from>, integral_c<T, to>);
 #else
     template <typename T, T from, T to>
-    constexpr range<T, from, to> range_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr range<T, from, to> range_c{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_RANGE_HPP
diff --git a/boost/hana/fwd/remove.hpp b/boost/hana/fwd/remove.hpp
index 88254410a9f52da45a77b959280a50aa4afef4ef..a46db55c2f10d1ebaac7ff3c390f5e19c8cec148 100644
--- a/boost/hana/fwd/remove.hpp
+++ b/boost/hana/fwd/remove.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Remove all the elements of a monadic structure that are equal to some
     //! value.
     //! @ingroup group-MonadPlus
@@ -63,8 +63,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Value&& value) const;
     };
 
-    constexpr remove_t remove{};
+    BOOST_HANA_INLINE_VARIABLE constexpr remove_t remove{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_REMOVE_HPP
diff --git a/boost/hana/fwd/remove_at.hpp b/boost/hana/fwd/remove_at.hpp
index f997d6e4c5352ab3b6b2706fea51dfdcadc707b8..14dc640eff75a035aca8781836082cc4180168bd 100644
--- a/boost/hana/fwd/remove_at.hpp
+++ b/boost/hana/fwd/remove_at.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Remove the element at a given index from a sequence.
     //! @ingroup group-Sequence
     //!
@@ -55,7 +55,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, N const& n) const;
     };
 
-    constexpr remove_at_t remove_at{};
+    BOOST_HANA_INLINE_VARIABLE constexpr remove_at_t remove_at{};
 #endif
 
     //! Equivalent to `remove_at`; provided for convenience.
@@ -75,8 +75,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct remove_at_c_t;
 
     template <std::size_t n>
-    constexpr remove_at_c_t<n> remove_at_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr remove_at_c_t<n> remove_at_c{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_REMOVE_AT_HPP
diff --git a/boost/hana/fwd/remove_if.hpp b/boost/hana/fwd/remove_if.hpp
index 590a6e195e4186ed1612c3ecf83fb7e3b19a23e2..ec964e0b9edf8d008320ba00c6b71f7e7363d888 100644
--- a/boost/hana/fwd/remove_if.hpp
+++ b/boost/hana/fwd/remove_if.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Remove all the elements of a monadic structure that satisfy some
     //! predicate.
     //! @ingroup group-MonadPlus
@@ -62,8 +62,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred&& pred) const;
     };
 
-    constexpr remove_if_t remove_if{};
+    BOOST_HANA_INLINE_VARIABLE constexpr remove_if_t remove_if{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_REMOVE_IF_HPP
diff --git a/boost/hana/fwd/remove_range.hpp b/boost/hana/fwd/remove_range.hpp
index 1645cce5987abe4fd284ed24d1b82e746814924f..83df1873f37f602933c5f4b129af0148e965f90e 100644
--- a/boost/hana/fwd/remove_range.hpp
+++ b/boost/hana/fwd/remove_range.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Remove the elements inside a given range of indices from a sequence.
     //! @ingroup group-Sequence
     //!
@@ -58,7 +58,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, From const& from, To const& to) const;
     };
 
-    constexpr remove_range_t remove_range{};
+    BOOST_HANA_INLINE_VARIABLE constexpr remove_range_t remove_range{};
 #endif
 
     //! Equivalent to `remove_range`; provided for convenience.
@@ -78,8 +78,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct remove_range_c_t;
 
     template <std::size_t from, std::size_t to>
-    constexpr remove_range_c_t<from, to> remove_range_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr remove_range_c_t<from, to> remove_range_c{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_REMOVE_RANGE_HPP
diff --git a/boost/hana/fwd/repeat.hpp b/boost/hana/fwd/repeat.hpp
index 0151b5c9e067bf5a0bd8711080ab01978d745d10..243bd3770b7cdceafe883ad600693d4ea71b18a6 100644
--- a/boost/hana/fwd/repeat.hpp
+++ b/boost/hana/fwd/repeat.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Invokes a nullary function `n` times.
     //! @ingroup group-IntegralConstant
     //!
@@ -51,8 +51,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr void operator()(N const& n, F&& f) const;
     };
 
-    constexpr repeat_t repeat{};
+    BOOST_HANA_INLINE_VARIABLE constexpr repeat_t repeat{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_REPEAT_HPP
diff --git a/boost/hana/fwd/replace.hpp b/boost/hana/fwd/replace.hpp
index 6edb858a7fd95ca5e153e9c1d0c540052f896556..dae7c306944d7b64c7214bcaee588404a38377fa 100644
--- a/boost/hana/fwd/replace.hpp
+++ b/boost/hana/fwd/replace.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Replace all the elements of a structure that compare equal
     //! to some `value` with some new fixed value.
     //! @ingroup group-Functor
@@ -57,8 +57,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, OldVal&& oldval, NewVal&& newval) const;
     };
 
-    constexpr replace_t replace{};
+    BOOST_HANA_INLINE_VARIABLE constexpr replace_t replace{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_REPLACE_HPP
diff --git a/boost/hana/fwd/replace_if.hpp b/boost/hana/fwd/replace_if.hpp
index 48d5b4c15c2dd7c042b10574a20e83ca0632523e..8f404fe74995bf60ba373458f9ec1d50a22f9805 100644
--- a/boost/hana/fwd/replace_if.hpp
+++ b/boost/hana/fwd/replace_if.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Replace all the elements of a structure satisfying a `predicate`
     //! with a fixed value.
     //! @ingroup group-Functor
@@ -56,8 +56,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred&& pred, Value&& value) const;
     };
 
-    constexpr replace_if_t replace_if{};
+    BOOST_HANA_INLINE_VARIABLE constexpr replace_if_t replace_if{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_REPLACE_IF_HPP
diff --git a/boost/hana/fwd/replicate.hpp b/boost/hana/fwd/replicate.hpp
index 842812d69257807df3bbafff0a9924429c0cf7f6..7247169341f16a8d2ae3ced725033ea64ab7579d 100644
--- a/boost/hana/fwd/replicate.hpp
+++ b/boost/hana/fwd/replicate.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Create a monadic structure by combining a lifted value with itself
     //! `n` times.
     //! @ingroup group-MonadPlus
@@ -71,8 +71,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <typename M>
-    constexpr replicate_t<M> replicate{};
+    BOOST_HANA_INLINE_VARIABLE constexpr replicate_t<M> replicate{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_REPLICATE_HPP
diff --git a/boost/hana/fwd/reverse.hpp b/boost/hana/fwd/reverse.hpp
index b47b610bb86dfd04ab4cafe687492abaada7fa05..9f952f5e59dd2a83dd5ccc84ecc218eadc9b7f24 100644
--- a/boost/hana/fwd/reverse.hpp
+++ b/boost/hana/fwd/reverse.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Reverse a sequence.
     //! @ingroup group-Sequence
     //!
@@ -42,8 +42,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs) const;
     };
 
-    constexpr reverse_t reverse{};
+    BOOST_HANA_INLINE_VARIABLE constexpr reverse_t reverse{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_REVERSE_HPP
diff --git a/boost/hana/fwd/reverse_fold.hpp b/boost/hana/fwd/reverse_fold.hpp
index 607dd2dc4d105c5e63e6717beed0a4432793001a..ab2960af6783729943d906fefbe151710f76c1af 100644
--- a/boost/hana/fwd/reverse_fold.hpp
+++ b/boost/hana/fwd/reverse_fold.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Equivalent to `reverse_fold` in Boost.Fusion and Boost.MPL.
     //! @ingroup group-Foldable
     //!
@@ -77,8 +77,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Xs&& xs, F&& f) const;
     };
 
-    constexpr reverse_fold_t reverse_fold{};
+    BOOST_HANA_INLINE_VARIABLE constexpr reverse_fold_t reverse_fold{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_REVERSE_FOLD_HPP
diff --git a/boost/hana/fwd/scan_left.hpp b/boost/hana/fwd/scan_left.hpp
index 2418196d324c6b05d60bf30258186eec5a3f8c3f..92f4450da20e7b4477f49781fc4d0f40df464255 100644
--- a/boost/hana/fwd/scan_left.hpp
+++ b/boost/hana/fwd/scan_left.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Fold a Sequence to the left and return a list containing the
     //! successive reduction states.
     //! @ingroup group-Sequence
@@ -98,8 +98,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, F const& f) const;
     };
 
-    constexpr scan_left_t scan_left{};
+    BOOST_HANA_INLINE_VARIABLE constexpr scan_left_t scan_left{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_SCAN_LEFT_HPP
diff --git a/boost/hana/fwd/scan_right.hpp b/boost/hana/fwd/scan_right.hpp
index c99cc911e9720ed30a8f4cdc8b83e720064ea8d6..b3a41bb0f53b749af72ec49a1f7ba30db1a38a73 100644
--- a/boost/hana/fwd/scan_right.hpp
+++ b/boost/hana/fwd/scan_right.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Fold a Sequence to the right and return a list containing the
     //! successive reduction states.
     //! @ingroup group-Sequence
@@ -98,8 +98,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, F const& f) const;
     };
 
-    constexpr scan_right_t scan_right{};
+    BOOST_HANA_INLINE_VARIABLE constexpr scan_right_t scan_right{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_SCAN_RIGHT_HPP
diff --git a/boost/hana/fwd/second.hpp b/boost/hana/fwd/second.hpp
index 6dc4623b79b5ea5ef1e01a95955f2a0f413b3fb0..23e7a012ec78926acdb1ff3bdadb70fec6c7f030 100644
--- a/boost/hana/fwd/second.hpp
+++ b/boost/hana/fwd/second.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns the second element of a pair.
     //! @ingroup group-Product
     //!
@@ -41,8 +41,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Pair&& pair) const;
     };
 
-    constexpr second_t second{};
+    BOOST_HANA_INLINE_VARIABLE constexpr second_t second{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_SECOND_HPP
diff --git a/boost/hana/fwd/set.hpp b/boost/hana/fwd/set.hpp
index acbcbc7fb56d9c684a5c77eb78abc10f74eadfbf..b85b26aedb29afcfd95ecfecaccb906a24bbffbf 100644
--- a/boost/hana/fwd/set.hpp
+++ b/boost/hana/fwd/set.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/erase_key.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-datatypes
     //! Basic unordered container requiring unique, `Comparable` and
     //! `Hashable` keys.
@@ -133,7 +133,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! Example
     //! -------
     //! @include example/set/make.cpp
-    constexpr auto make_set = make<set_tag>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto make_set = make<set_tag>;
 
     //! Insert an element in a `hana::set`.
     //! @relates hana::set
@@ -293,6 +293,6 @@ constexpr auto symmetric_difference = [](auto&& xs, auto&& ys) {
 #endif
 
 
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_SET_HPP
diff --git a/boost/hana/fwd/size.hpp b/boost/hana/fwd/size.hpp
index 8999b914138b13ac851f9fa24a4e834ec470cb4e..624fd09e5d3b87b2fd950984200999b92e17551e 100644
--- a/boost/hana/fwd/size.hpp
+++ b/boost/hana/fwd/size.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/length.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Equivalent to `length`; provided for consistency with the
     //! standard library.
     //! @ingroup group-Foldable
@@ -27,7 +27,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! Example
     //! -------
     //! @include example/size.cpp
-    constexpr auto size = hana::length;
-BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr auto size = hana::length;
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_SIZE_HPP
diff --git a/boost/hana/fwd/slice.hpp b/boost/hana/fwd/slice.hpp
index f8dfafc02dc380d9758912ed6790c7469e1d4952..af24f95177ec6927b60982b05b8fdd9637efff4a 100644
--- a/boost/hana/fwd/slice.hpp
+++ b/boost/hana/fwd/slice.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Extract the elements of a `Sequence` at the given indices.
     //! @ingroup group-Sequence
     //!
@@ -62,7 +62,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Indices&& indices) const;
     };
 
-    constexpr slice_t slice{};
+    BOOST_HANA_INLINE_VARIABLE constexpr slice_t slice{};
 #endif
 
     //! Shorthand to `slice` a contiguous range of elements.
@@ -98,8 +98,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct slice_c_t;
 
     template <std::size_t from, std::size_t to>
-    constexpr slice_c_t<from, to> slice_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr slice_c_t<from, to> slice_c{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_SLICE_HPP
diff --git a/boost/hana/fwd/sort.hpp b/boost/hana/fwd/sort.hpp
index c0d45aee23cd292176316cb7685dfdbba4129c5a..663e23cb0acc45c634efa35e378daf25d73d50d7 100644
--- a/boost/hana/fwd/sort.hpp
+++ b/boost/hana/fwd/sort.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/nested_by_fwd.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Sort a sequence, optionally based on a custom `predicate`.
     //! @ingroup group-Sequence
     //!
@@ -96,8 +96,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Predicate&& pred) const;
     };
 
-    constexpr sort_t sort{};
+    BOOST_HANA_INLINE_VARIABLE constexpr sort_t sort{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_SORT_HPP
diff --git a/boost/hana/fwd/span.hpp b/boost/hana/fwd/span.hpp
index 047b2bc17480368f411f655c45f45d88f06e37e4..487114eb091cb8f3bf84579a3dd9cbb43645decc 100644
--- a/boost/hana/fwd/span.hpp
+++ b/boost/hana/fwd/span.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/nested_by_fwd.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns a `Product` containing the longest prefix of a sequence
     //! satisfying a predicate, and the rest of the sequence.
     //! @ingroup group-Sequence
@@ -78,8 +78,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred&& pred) const;
     };
 
-    constexpr span_t span{};
+    BOOST_HANA_INLINE_VARIABLE constexpr span_t span{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_SPAN_HPP
diff --git a/boost/hana/fwd/string.hpp b/boost/hana/fwd/string.hpp
index 8af2e709ba9174a87babf9148bf542ff38df5123..3c8f9561105627d03c40b753fc30e0c666439eaf 100644
--- a/boost/hana/fwd/string.hpp
+++ b/boost/hana/fwd/string.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/core/to.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
 #ifdef BOOST_HANA_DOXYGEN_INVOKED
     //! @ingroup group-datatypes
     //! Compile-time string.
@@ -187,11 +187,11 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! Alias to `make<string_tag>`; provided for convenience.
     //! @relates hana::string
-    constexpr auto make_string = make<string_tag>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto make_string = make<string_tag>;
 
     //! Equivalent to `to<string_tag>`; provided for convenience.
     //! @relates hana::string
-    constexpr auto to_string = to<string_tag>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto to_string = to<string_tag>;
 
     //! Create a compile-time string from a parameter pack of characters.
     //! @relates hana::string
@@ -205,7 +205,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     constexpr string<implementation_defined> string_c{};
 #else
     template <char ...s>
-    constexpr string<s...> string_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr string<s...> string_c{};
 #endif
 
     //! Create a compile-time string from a string literal.
@@ -268,6 +268,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator"" _s();
     }
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_STRING_HPP
diff --git a/boost/hana/fwd/suffix.hpp b/boost/hana/fwd/suffix.hpp
index 331854fe5d3919d6183f3f8323f9c13717cbaa70..f566778acca6c999accc8dd7b836c7f89efd631d 100644
--- a/boost/hana/fwd/suffix.hpp
+++ b/boost/hana/fwd/suffix.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Inserts a value after each element of a monadic structure.
     //! @ingroup group-MonadPlus
     //!
@@ -65,8 +65,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Sfx&& sfx) const;
     };
 
-    constexpr suffix_t suffix{};
+    BOOST_HANA_INLINE_VARIABLE constexpr suffix_t suffix{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_SUFFIX_HPP
diff --git a/boost/hana/fwd/sum.hpp b/boost/hana/fwd/sum.hpp
index 6d7ee537b3e37e7c1324ebe73d759e28a20ad61e..a1581cfd86f12ba906c44ca9a7e1124cb836643b 100644
--- a/boost/hana/fwd/sum.hpp
+++ b/boost/hana/fwd/sum.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/integral_constant.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Compute the sum of the numbers of a structure.
     //! @ingroup group-Foldable
     //!
@@ -75,8 +75,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <typename M = integral_constant_tag<int>>
-    constexpr sum_t<M> sum{};
+    BOOST_HANA_INLINE_VARIABLE constexpr sum_t<M> sum{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_SUM_HPP
diff --git a/boost/hana/fwd/symmetric_difference.hpp b/boost/hana/fwd/symmetric_difference.hpp
index 2253f167eb83fbed4159f224a61b21c2b0e74a39..e7a5b09ca55f080881cb1bc76b026738055d73e1 100644
--- a/boost/hana/fwd/symmetric_difference.hpp
+++ b/boost/hana/fwd/symmetric_difference.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     // Note: This function is documented per datatype/concept only.
     //! @cond
     template <typename S, typename = void>
@@ -26,7 +26,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&&, Ys&&) const;
     };
 
-    constexpr symmetric_difference_t symmetric_difference{};
-BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr symmetric_difference_t symmetric_difference{};
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_SYMMETRIC_DIFFERENCE_HPP
diff --git a/boost/hana/fwd/take_back.hpp b/boost/hana/fwd/take_back.hpp
index 5ba1cf932f32571266cb1d29348eb274f5ee0b2d..4cb3e42b18c049556d620245060dc0eb611dca53 100644
--- a/boost/hana/fwd/take_back.hpp
+++ b/boost/hana/fwd/take_back.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns the last `n` elements of a sequence, or the whole sequence
     //! if the sequence has less than `n` elements.
     //! @ingroup group-Sequence
@@ -51,7 +51,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, N const& n) const;
     };
 
-    constexpr take_back_t take_back{};
+    BOOST_HANA_INLINE_VARIABLE constexpr take_back_t take_back{};
 #endif
 
     //! Equivalent to `take_back`; provided for convenience.
@@ -71,8 +71,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct take_back_c_t;
 
     template <std::size_t n>
-    constexpr take_back_c_t<n> take_back_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr take_back_c_t<n> take_back_c{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_TAKE_BACK_HPP
diff --git a/boost/hana/fwd/take_front.hpp b/boost/hana/fwd/take_front.hpp
index 9ce3b9c030dd3aecbabf7bf03af7a41401e91c5b..cd253bae5868c0b074b6e3f90d12c85103263498 100644
--- a/boost/hana/fwd/take_front.hpp
+++ b/boost/hana/fwd/take_front.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Returns the first `n` elements of a sequence, or the whole sequence
     //! if the sequence has less than `n` elements.
     //! @ingroup group-Sequence
@@ -51,7 +51,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, N const& n) const;
     };
 
-    constexpr take_front_t take_front{};
+    BOOST_HANA_INLINE_VARIABLE constexpr take_front_t take_front{};
 #endif
 
     //! Equivalent to `take_front`; provided for convenience.
@@ -71,8 +71,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct take_front_c_t;
 
     template <std::size_t n>
-    constexpr take_front_c_t<n> take_front_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr take_front_c_t<n> take_front_c{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_TAKE_FRONT_HPP
diff --git a/boost/hana/fwd/take_while.hpp b/boost/hana/fwd/take_while.hpp
index 29f1ba24e0bd522a30183a2bc485e00192b22895..61aa5715a2f45bc42521ea67a5a9ec0f35b08572 100644
--- a/boost/hana/fwd/take_while.hpp
+++ b/boost/hana/fwd/take_while.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Take elements from a sequence while the `predicate` is satisfied.
     //! @ingroup group-Sequence
     //!
@@ -49,8 +49,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Pred&& pred) const;
     };
 
-    constexpr take_while_t take_while{};
+    BOOST_HANA_INLINE_VARIABLE constexpr take_while_t take_while{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_TAKE_WHILE_HPP
diff --git a/boost/hana/fwd/tap.hpp b/boost/hana/fwd/tap.hpp
index 2f3809c1f394a08c7f2ad4e4bbe7339a9043d6a5..d506694704501898dda22067721924edec0f67d2 100644
--- a/boost/hana/fwd/tap.hpp
+++ b/boost/hana/fwd/tap.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Tap inside a monadic chain.
     //! @ingroup group-Monad
     //!
@@ -61,8 +61,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <typename M>
-    constexpr tap_t<M> tap{};
+    BOOST_HANA_INLINE_VARIABLE constexpr tap_t<M> tap{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_TAP_HPP
diff --git a/boost/hana/fwd/then.hpp b/boost/hana/fwd/then.hpp
index b4adf3d4feefc1dac63ad3b0bbbf03412c0975be..8b8dd9b83b733e4ce38d8dcd410dab3bb214fd27 100644
--- a/boost/hana/fwd/then.hpp
+++ b/boost/hana/fwd/then.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Sequentially compose two monadic actions, discarding any value
     //! produced by the first but not its effects.
     //! @ingroup group-Monad
@@ -45,8 +45,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Before&& before, Xs&& xs) const;
     };
 
-    constexpr then_t then{};
+    BOOST_HANA_INLINE_VARIABLE constexpr then_t then{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_THEN_HPP
diff --git a/boost/hana/fwd/transform.hpp b/boost/hana/fwd/transform.hpp
index af645f3d2383c9c6b906f6c97736f5013bc90e37..a7a42ce1e747f5c0aab46cfe6e691466a4f99602 100644
--- a/boost/hana/fwd/transform.hpp
+++ b/boost/hana/fwd/transform.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Map a function over a `Functor`.
     //! @ingroup group-Functor
     //!
@@ -50,8 +50,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, F&& f) const;
     };
 
-    constexpr transform_t transform{};
+    BOOST_HANA_INLINE_VARIABLE constexpr transform_t transform{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_TRANSFORM_HPP
diff --git a/boost/hana/fwd/tuple.hpp b/boost/hana/fwd/tuple.hpp
index 9ee2e00ace1afd25ac4646ba476e7d6a41b61b4c..08d2c7728366bf4fa8e79812d6ff90e764754391 100644
--- a/boost/hana/fwd/tuple.hpp
+++ b/boost/hana/fwd/tuple.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/type.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @ingroup group-datatypes
     //! General purpose index-based heterogeneous sequence with a fixed length.
     //!
@@ -179,11 +179,11 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     //! Alias to `make<tuple_tag>`; provided for convenience.
     //! @relates hana::tuple
-    constexpr auto make_tuple = make<tuple_tag>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto make_tuple = make<tuple_tag>;
 
     //! Equivalent to `to<tuple_tag>`; provided for convenience.
     //! @relates hana::tuple
-    constexpr auto to_tuple = to<tuple_tag>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto to_tuple = to<tuple_tag>;
 
     //! Create a tuple specialized for holding `hana::type`s.
     //! @relates hana::tuple
@@ -202,7 +202,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     constexpr implementation_defined tuple_t{};
 #else
     template <typename ...T>
-    constexpr hana::tuple<hana::type<T>...> tuple_t{};
+    BOOST_HANA_INLINE_VARIABLE constexpr hana::tuple<hana::type<T>...> tuple_t{};
 #endif
 
     //! Create a tuple specialized for holding `hana::integral_constant`s.
@@ -222,8 +222,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     constexpr implementation_defined tuple_c{};
 #else
     template <typename T, T ...v>
-    constexpr hana::tuple<hana::integral_constant<T, v>...> tuple_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr hana::tuple<hana::integral_constant<T, v>...> tuple_c{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_TUPLE_HPP
diff --git a/boost/hana/fwd/type.hpp b/boost/hana/fwd/type.hpp
index d087cee1660f2a5ba536fb137c7fcdf2216d4f14..26a2ec1d35cfdb2bc0568a49610e469674c7f8b3 100644
--- a/boost/hana/fwd/type.hpp
+++ b/boost/hana/fwd/type.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/core/make.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Base class of `hana::type`; used for pattern-matching.
     //! @relates hana::type
     //!
@@ -125,7 +125,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! Creates an object representing the C++ type `T`.
     //! @relates hana::type
     template <typename T>
-    constexpr type<T> type_c{};
+    BOOST_HANA_INLINE_VARIABLE constexpr type<T> type_c{};
 
     //! `decltype` keyword, lifted to Hana.
     //! @relates hana::type
@@ -194,7 +194,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(T&&) const;
     };
 
-    constexpr decltype_t decltype_{};
+    BOOST_HANA_INLINE_VARIABLE constexpr decltype_t decltype_{};
 #endif
 
     //! Returns a `hana::type` representing the type of a given object.
@@ -237,7 +237,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(T&&) const;
     };
 
-    constexpr typeid_t typeid_{};
+    BOOST_HANA_INLINE_VARIABLE constexpr typeid_t typeid_{};
 #endif
 
 #ifdef BOOST_HANA_DOXYGEN_INVOKED
@@ -259,7 +259,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! Example
     //! -------
     //! @include example/type/make.cpp
-    constexpr auto make_type = hana::make<type_tag>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto make_type = hana::make<type_tag>;
 
     //! `sizeof` keyword, lifted to Hana.
     //! @relates hana::type
@@ -297,7 +297,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(T&&) const;
     };
 
-    constexpr sizeof_t sizeof_{};
+    BOOST_HANA_INLINE_VARIABLE constexpr sizeof_t sizeof_{};
 #endif
 
     //! `alignof` keyword, lifted to Hana.
@@ -333,7 +333,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(T&&) const;
     };
 
-    constexpr alignof_t alignof_{};
+    BOOST_HANA_INLINE_VARIABLE constexpr alignof_t alignof_{};
 #endif
 
     //! Checks whether a SFINAE-friendly expression is valid.
@@ -380,7 +380,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(F&&, Args&&...) const;
     };
 
-    constexpr is_valid_t is_valid{};
+    BOOST_HANA_INLINE_VARIABLE constexpr is_valid_t is_valid{};
 #endif
 
     //! Lift a template to a Metafunction.
@@ -411,7 +411,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct template_t;
 
     template <template <typename ...> class F>
-    constexpr template_t<F> template_{};
+    BOOST_HANA_INLINE_VARIABLE constexpr template_t<F> template_{};
 #endif
 
     //! Lift a MPL-style metafunction to a Metafunction.
@@ -442,7 +442,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct metafunction_t;
 
     template <template <typename ...> class f>
-    constexpr metafunction_t<f> metafunction{};
+    BOOST_HANA_INLINE_VARIABLE constexpr metafunction_t<f> metafunction{};
 #endif
 
     //! Lift a MPL-style metafunction class to a Metafunction.
@@ -473,7 +473,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct metafunction_class_t;
 
     template <typename F>
-    constexpr metafunction_class_t<F> metafunction_class{};
+    BOOST_HANA_INLINE_VARIABLE constexpr metafunction_class_t<F> metafunction_class{};
 #endif
 
     //! Turn a `Metafunction` into a function taking `type`s and returning a
@@ -525,7 +525,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         { return {}; }
     };
 
-    constexpr make_integral_t integral{};
+    BOOST_HANA_INLINE_VARIABLE constexpr make_integral_t integral{};
 #endif
 
     //! Alias to `integral(metafunction<F>)`, provided for convenience.
@@ -536,7 +536,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! -------
     //! @include example/type/trait.cpp
     template <template <typename ...> class F>
-    constexpr auto trait = hana::integral(hana::metafunction<F>);
-BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr auto trait = hana::integral(hana::metafunction<F>);
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_TYPE_HPP
diff --git a/boost/hana/fwd/unfold_left.hpp b/boost/hana/fwd/unfold_left.hpp
index d753222630fbd47868399a29863e09c79b71db9b..622e6329abfdfde1ff234449e56a1aca18433ac1 100644
--- a/boost/hana/fwd/unfold_left.hpp
+++ b/boost/hana/fwd/unfold_left.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Dual operation to `fold_left` for sequences.
     //! @ingroup group-Sequence
     //!
@@ -78,8 +78,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct unfold_left_t;
 
     template <typename S>
-    constexpr unfold_left_t<S> unfold_left{};
+    BOOST_HANA_INLINE_VARIABLE constexpr unfold_left_t<S> unfold_left{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_UNFOLD_LEFT_HPP
diff --git a/boost/hana/fwd/unfold_right.hpp b/boost/hana/fwd/unfold_right.hpp
index 53ee56fc48f4410db77ba3dbcd2c2beeb0986f4c..b06b49eb1734b55c9a033ba83a6cef07ff44c807 100644
--- a/boost/hana/fwd/unfold_right.hpp
+++ b/boost/hana/fwd/unfold_right.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Dual operation to `fold_right` for sequences.
     //! @ingroup group-Sequence
     //!
@@ -78,8 +78,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct unfold_right_t;
 
     template <typename S>
-    constexpr unfold_right_t<S> unfold_right{};
+    BOOST_HANA_INLINE_VARIABLE constexpr unfold_right_t<S> unfold_right{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_UNFOLD_RIGHT_HPP
diff --git a/boost/hana/fwd/union.hpp b/boost/hana/fwd/union.hpp
index 577515188899693082058f4fd82db09eba13bfd6..3a298b323328e904fd1e0cdcc7ac82d8dc7ae390 100644
--- a/boost/hana/fwd/union.hpp
+++ b/boost/hana/fwd/union.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     // Note: This function is documented per datatype/concept only.
     //! @cond
     template <typename T, typename = void>
@@ -26,7 +26,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&&, Ys&&) const;
     };
 
-    constexpr union_t union_{};
-BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr union_t union_{};
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_UNION_HPP
diff --git a/boost/hana/fwd/unique.hpp b/boost/hana/fwd/unique.hpp
index 5eab73eb3b7957bd76a009c9cc947c8b9e715b1c..7704d5bbfb8e92e76eb3122901da6afddba4a728 100644
--- a/boost/hana/fwd/unique.hpp
+++ b/boost/hana/fwd/unique.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/nested_by_fwd.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Removes all consecutive duplicate elements from a Sequence.
     //! @ingroup group-Sequence
     //!
@@ -84,8 +84,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Predicate&& predicate) const;
     };
 
-    constexpr unique_t unique{};
+    BOOST_HANA_INLINE_VARIABLE constexpr unique_t unique{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_UNIQUE_HPP
diff --git a/boost/hana/fwd/unpack.hpp b/boost/hana/fwd/unpack.hpp
index f66c29ae8b49b99ff752e64a348149d4200cd250..f6520f94435ae9dfcc4f1c2ae4056adf160f4265 100644
--- a/boost/hana/fwd/unpack.hpp
+++ b/boost/hana/fwd/unpack.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Invoke a function with the elements of a Foldable as arguments.
     //! @ingroup group-Foldable
     //!
@@ -88,8 +88,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Xs&& xs, F&& f) const;
     };
 
-    constexpr unpack_t unpack{};
+    BOOST_HANA_INLINE_VARIABLE constexpr unpack_t unpack{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_UNPACK_HPP
diff --git a/boost/hana/fwd/value.hpp b/boost/hana/fwd/value.hpp
index 7db9384f775b0c4736851fd363722a9314fd0a37..dcfaedb428be7da70b09877a9fce5f4fc68a3679 100644
--- a/boost/hana/fwd/value.hpp
+++ b/boost/hana/fwd/value.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Return the compile-time value associated to a constant.
     //! @ingroup group-Constant
     //!
@@ -93,8 +93,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         { return hana::value<T>(); }
     };
 
-    constexpr value_of_t value_of{};
+    BOOST_HANA_INLINE_VARIABLE constexpr value_of_t value_of{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_VALUE_HPP
diff --git a/boost/hana/fwd/while.hpp b/boost/hana/fwd/while.hpp
index 14923797b564f3afb27f6f082459e46bf38b8a3c..cbc2b4569d3c5406221ad960d0bc9baeecedad1d 100644
--- a/boost/hana/fwd/while.hpp
+++ b/boost/hana/fwd/while.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Apply a function to an initial state while some predicate is satisfied.
     //! @ingroup group-Logical
     //!
@@ -64,8 +64,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Pred&& pred, State&& state, F&& f) const;
     };
 
-    constexpr while_t while_{};
+    BOOST_HANA_INLINE_VARIABLE constexpr while_t while_{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_WHILE_HPP
diff --git a/boost/hana/fwd/zero.hpp b/boost/hana/fwd/zero.hpp
index fcbcfcc372423efda541e2e42887d872b3776f51..47546113b38da8478d62b56210bd1008289e79a6 100644
--- a/boost/hana/fwd/zero.hpp
+++ b/boost/hana/fwd/zero.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Identity of `plus`.
     //! @ingroup group-Monoid
     //!
@@ -40,8 +40,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <typename M>
-    constexpr zero_t<M> zero{};
+    BOOST_HANA_INLINE_VARIABLE constexpr zero_t<M> zero{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ZERO_HPP
diff --git a/boost/hana/fwd/zip.hpp b/boost/hana/fwd/zip.hpp
index 505decfcf062694a1d942c871da622c2b9b6cea1..66a4202d04905aed5243ac6873b46dc2e441f814 100644
--- a/boost/hana/fwd/zip.hpp
+++ b/boost/hana/fwd/zip.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Zip one sequence or more.
     //! @ingroup group-Sequence
     //!
@@ -54,8 +54,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Ys&& ...ys) const;
     };
 
-    constexpr zip_t zip{};
+    BOOST_HANA_INLINE_VARIABLE constexpr zip_t zip{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ZIP_HPP
diff --git a/boost/hana/fwd/zip_shortest.hpp b/boost/hana/fwd/zip_shortest.hpp
index 5f0622789d66adec0d24a877672665a7371588c5..90cdedc52d65b009ee1cead3f39d33b6741233e5 100644
--- a/boost/hana/fwd/zip_shortest.hpp
+++ b/boost/hana/fwd/zip_shortest.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Zip one sequence or more.
     //! @ingroup group-Sequence
     //!
@@ -54,8 +54,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(Xs&& xs, Ys&& ...ys) const;
     };
 
-    constexpr zip_shortest_t zip_shortest{};
+    BOOST_HANA_INLINE_VARIABLE constexpr zip_shortest_t zip_shortest{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ZIP_SHORTEST_HPP
diff --git a/boost/hana/fwd/zip_shortest_with.hpp b/boost/hana/fwd/zip_shortest_with.hpp
index 47d5a43b6145fac3b620d8cc8ada72e9be4758ce..9106354cdf30dfe1df005ac70823a671e0c53d9a 100644
--- a/boost/hana/fwd/zip_shortest_with.hpp
+++ b/boost/hana/fwd/zip_shortest_with.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Zip one sequence or more with a given function.
     //! @ingroup group-Sequence
     //!
@@ -55,8 +55,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(F&& f, Xs&& xs, Ys&& ...ys) const;
     };
 
-    constexpr zip_shortest_with_t zip_shortest_with{};
+    BOOST_HANA_INLINE_VARIABLE constexpr zip_shortest_with_t zip_shortest_with{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ZIP_SHORTEST_WITH_HPP
diff --git a/boost/hana/fwd/zip_with.hpp b/boost/hana/fwd/zip_with.hpp
index 3e153a3e6a1b7ecaab342154fe388466567143c4..0055b15ad3bdc3b81b3064d112c9838344a3e8a6 100644
--- a/boost/hana/fwd/zip_with.hpp
+++ b/boost/hana/fwd/zip_with.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! Zip one sequence or more with a given function.
     //! @ingroup group-Sequence
     //!
@@ -55,8 +55,8 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr auto operator()(F&& f, Xs&& xs, Ys&& ...ys) const;
     };
 
-    constexpr zip_with_t zip_with{};
+    BOOST_HANA_INLINE_VARIABLE constexpr zip_with_t zip_with{};
 #endif
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_ZIP_WITH_HPP
diff --git a/boost/hana/greater.hpp b/boost/hana/greater.hpp
index 84f7e23a1a82315ffeb3134800d89fb873ad88d8..29428b168f9aaf51640aa6d1110b985e0828a796 100644
--- a/boost/hana/greater.hpp
+++ b/boost/hana/greater.hpp
@@ -23,7 +23,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/if.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr decltype(auto) greater_t::operator()(X&& x, Y&& y) const {
@@ -66,6 +66,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                  hana::to<C>(static_cast<Y&&>(y)));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_GREATER_HPP
diff --git a/boost/hana/greater_equal.hpp b/boost/hana/greater_equal.hpp
index e9b34d2587af6b19abda4593610caa8500137e81..2562f3bc9d03adff7e38256c947a1a45ee1d1a41 100644
--- a/boost/hana/greater_equal.hpp
+++ b/boost/hana/greater_equal.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/not.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr decltype(auto) greater_equal_t::operator()(X&& x, Y&& y) const {
@@ -69,6 +69,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                        hana::to<C>(static_cast<Y&&>(y)));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_GREATER_EQUAL_HPP
diff --git a/boost/hana/group.hpp b/boost/hana/group.hpp
index 52a3d64f70158ca20200b58a1eeeeb43c4e14cbb..5fd75764783434bad16dd33c8a4785825acaf9a6 100644
--- a/boost/hana/group.hpp
+++ b/boost/hana/group.hpp
@@ -27,7 +27,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr auto group_t::operator()(Xs&& xs) const {
@@ -153,6 +153,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr auto apply(Xs&& xs)
         { return group_impl::apply(static_cast<Xs&&>(xs), hana::equal); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_GROUP_HPP
diff --git a/boost/hana/hash.hpp b/boost/hana/hash.hpp
index 538ef36ecacc1d520a23a5e1997bd8384af952b3..6f4e5ff227f5b82b93b401690a8293b18adf4fff 100644
--- a/boost/hana/hash.hpp
+++ b/boost/hana/hash.hpp
@@ -22,7 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X>
     constexpr auto hash_t::operator()(X const& x) const {
@@ -109,6 +109,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return detail::hash_integral_helper<T>::apply(x);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_HASH_HPP
diff --git a/boost/hana/if.hpp b/boost/hana/if.hpp
index 5d7f2bb9699db258b4d9b8a49e08b1e3e6d5a709..e1576f5cb95c977d909579cc7c737414675e45c7 100644
--- a/boost/hana/if.hpp
+++ b/boost/hana/if.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/eval_if.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Cond, typename Then, typename Else>
     constexpr decltype(auto) if_t::operator()(Cond&& cond, Then&& then_, Else&& else_) const {
@@ -56,6 +56,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_IF_HPP
diff --git a/boost/hana/index_if.hpp b/boost/hana/index_if.hpp
index dfa508a81ef334e9cbaa2e46df82a9a7e2ac9b88..ba3abeb378aa2b244c06df093d85e38471746c2f 100644
--- a/boost/hana/index_if.hpp
+++ b/boost/hana/index_if.hpp
@@ -27,7 +27,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred>
     constexpr auto index_if_t::operator()(Xs&& xs, Pred&& pred) const {
@@ -100,6 +100,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             -> typename detail::index_if<Pred, Xs...>::type
         { return {}; }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_INDEX_IF_HPP
diff --git a/boost/hana/insert.hpp b/boost/hana/insert.hpp
index 3752a64a29a909a19bf82be2b6eff9ac946a792f..aacd6e3555a254420e1032383ba4e2dcc891b9fe 100644
--- a/boost/hana/insert.hpp
+++ b/boost/hana/insert.hpp
@@ -21,7 +21,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/take_front.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Set, typename ...Args>
     constexpr decltype(auto) insert_t::operator()(Set&& set, Args&& ...args) const {
@@ -47,6 +47,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                 hana::drop_front(xs, n));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_INSERT_HPP
diff --git a/boost/hana/insert_range.hpp b/boost/hana/insert_range.hpp
index 26ad8f765e93103272366a1436144c43c79f7006..fbc61a7077c5589652fa2e7cff734bf755820e84 100644
--- a/boost/hana/insert_range.hpp
+++ b/boost/hana/insert_range.hpp
@@ -22,7 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/take_front.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename N, typename Elements>
     constexpr auto insert_range_t::operator()(Xs&& xs, N&& n, Elements&& elements) const {
@@ -59,6 +59,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                 );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_INSERT_RANGE_HPP
diff --git a/boost/hana/intersection.hpp b/boost/hana/intersection.hpp
index a9859d8f42999e51be83281ef6cda029b3a6bb2f..dbe12e8b6604c46b5fc19b23348d678d00823f03 100644
--- a/boost/hana/intersection.hpp
+++ b/boost/hana/intersection.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/dispatch.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Ys>
     constexpr auto intersection_t::operator()(Xs&& xs, Ys&& ys) const {
@@ -34,6 +34,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         template <typename ...Args>
         static constexpr auto apply(Args&& ...) = delete;
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_INTERSECTION_HPP
diff --git a/boost/hana/intersperse.hpp b/boost/hana/intersperse.hpp
index 13e8240a1348ca5e85213c88b847268428c8a53e..45df73a32afed13db94b27d90e228d6738bf876e 100644
--- a/boost/hana/intersperse.hpp
+++ b/boost/hana/intersperse.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Z>
     constexpr auto intersperse_t::operator()(Xs&& xs, Z&& z) const {
@@ -71,6 +71,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                       std::make_index_sequence<new_size>{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_INTERSPERSE_HPP
diff --git a/boost/hana/is_disjoint.hpp b/boost/hana/is_disjoint.hpp
index c4ffc7312181eff9649004ab864c8843a1de630b..d0c4396a8dfc2361a250e9e708d7bb965f1e191c 100644
--- a/boost/hana/is_disjoint.hpp
+++ b/boost/hana/is_disjoint.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/none_of.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Ys>
     constexpr auto is_disjoint_t::operator()(Xs&& xs, Ys&& ys) const {
@@ -60,6 +60,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::none_of(xs, detail::in_by_reference<Ys>{ys});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_IS_DISJOINT_HPP
diff --git a/boost/hana/is_empty.hpp b/boost/hana/is_empty.hpp
index a8b68fa61aaa36fe3a5d2a47bbc5d8024783fb28..4c3dc099726feff96f2058112cbbc2b4155b7cda 100644
--- a/boost/hana/is_empty.hpp
+++ b/boost/hana/is_empty.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/dispatch.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr auto is_empty_t::operator()(Xs const& xs) const {
@@ -40,6 +40,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         template <typename ...Args>
         static constexpr auto apply(Args&& ...) = delete;
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_IS_EMPTY_HPP
diff --git a/boost/hana/is_subset.hpp b/boost/hana/is_subset.hpp
index 7ef3e2bed5c81cee87517aa55f10a57adc6e2f8d..a26edd79d4fd69eba9e9200768b2af9f79c557e0 100644
--- a/boost/hana/is_subset.hpp
+++ b/boost/hana/is_subset.hpp
@@ -23,7 +23,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/partial.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Ys>
     constexpr auto is_subset_t::operator()(Xs&& xs, Ys&& ys) const {
@@ -79,6 +79,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                    hana::to<C>(static_cast<Ys&&>(ys)));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_IS_SUBSET_HPP
diff --git a/boost/hana/keys.hpp b/boost/hana/keys.hpp
index b27be1d756e41bb18fa0858e0f6c6ecbdda06644..65dc29715ba148e75b5879433423f12fa2d3f6e2 100644
--- a/boost/hana/keys.hpp
+++ b/boost/hana/keys.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/transform.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Map>
     constexpr auto keys_t::operator()(Map&& map) const {
@@ -43,6 +43,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::transform(hana::accessors<S>(), hana::first);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_KEYS_HPP
diff --git a/boost/hana/lazy.hpp b/boost/hana/lazy.hpp
index 5cb9a8a3abccf604b427885f711aba8f2a608158..ca8c25890362d22ec113b1ac8a91d3b09024112c 100644
--- a/boost/hana/lazy.hpp
+++ b/boost/hana/lazy.hpp
@@ -35,7 +35,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //////////////////////////////////////////////////////////////////////////
     // lazy
     //////////////////////////////////////////////////////////////////////////
@@ -224,6 +224,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::make_lazy(static_cast<F&&>(f))(static_cast<Expr&&>(expr));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_LAZY_HPP
diff --git a/boost/hana/length.hpp b/boost/hana/length.hpp
index 44c195b390c99f0b5010e08cbc3c5783a47aae30..3473893a6f4984fc1d577e3cc8aed2bc94caedd1 100644
--- a/boost/hana/length.hpp
+++ b/boost/hana/length.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/unpack.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr auto length_t::operator()(Xs const& xs) const {
@@ -52,6 +52,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::unpack(xs, detail::argn{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_LENGTH_HPP
diff --git a/boost/hana/less.hpp b/boost/hana/less.hpp
index 05cceabb1dcfe8e9d6242b60946e0a182a5dd29e..462df6a0b140848fec744e2f349777d88b19f848 100644
--- a/boost/hana/less.hpp
+++ b/boost/hana/less.hpp
@@ -35,7 +35,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/value.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr auto less_t::operator()(X&& x, Y&& y) const {
@@ -137,6 +137,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr auto apply(Xs const& xs, Ys const& ys)
         { return hana::lexicographical_compare(xs, ys); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_LESS_HPP
diff --git a/boost/hana/less_equal.hpp b/boost/hana/less_equal.hpp
index d3d0efe9112f86a294cc84b76b232817cc80d524..d284c80697e5f687ced71a99734e421b25189405 100644
--- a/boost/hana/less_equal.hpp
+++ b/boost/hana/less_equal.hpp
@@ -25,7 +25,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr auto less_equal_t::operator()(X&& x, Y&& y) const {
@@ -70,6 +70,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                     hana::to<C>(static_cast<Y&&>(y)));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_LESS_EQUAL_HPP
diff --git a/boost/hana/lexicographical_compare.hpp b/boost/hana/lexicographical_compare.hpp
index e8363ad9f11c4d433d8d1b06db101c27efba3ac2..9b4b65c6173f08351f707bfde304bc83eeca1241 100644
--- a/boost/hana/lexicographical_compare.hpp
+++ b/boost/hana/lexicographical_compare.hpp
@@ -23,7 +23,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/less.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Ys>
     constexpr auto lexicographical_compare_t::operator()(Xs const& xs, Ys const& ys) const {
@@ -105,6 +105,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             >);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_LEXICOGRAPHICAL_COMPARE_HPP
diff --git a/boost/hana/lift.hpp b/boost/hana/lift.hpp
index c1d7803788d58461f75840dd04f7b54b2bc02db1..8fa963a30256416f327287931461b5fd9f573273 100644
--- a/boost/hana/lift.hpp
+++ b/boost/hana/lift.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/make.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename A>
     template <typename X>
@@ -49,6 +49,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(X&& x)
         { return hana::make<S>(static_cast<X&&>(x)); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_LIFT_HPP
diff --git a/boost/hana/map.hpp b/boost/hana/map.hpp
index 7356208bc65324734e925938808094bc64076575..6a08003729ae3ccd61eea728193e1f251ce7be75 100644
--- a/boost/hana/map.hpp
+++ b/boost/hana/map.hpp
@@ -62,7 +62,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //////////////////////////////////////////////////////////////////////////
     // operators
     //////////////////////////////////////////////////////////////////////////
@@ -572,6 +572,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_MAP_HPP
diff --git a/boost/hana/max.hpp b/boost/hana/max.hpp
index 80889a791c4802a04eaf985c15ee74eab448bbbb..65a1978544d52163b1232d4c992a999f2e967a46 100644
--- a/boost/hana/max.hpp
+++ b/boost/hana/max.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/less.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr decltype(auto) max_t::operator()(X&& x, Y&& y) const {
@@ -53,6 +53,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_MAX_HPP
diff --git a/boost/hana/maximum.hpp b/boost/hana/maximum.hpp
index 14cb7abfd4679cb5d2ea7cc5e2e281216e21354a..6e3cbefc79f071f78bb434bb025f5320f8d1639e 100644
--- a/boost/hana/maximum.hpp
+++ b/boost/hana/maximum.hpp
@@ -21,7 +21,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/less.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr decltype(auto) maximum_t::operator()(Xs&& xs) const {
@@ -92,6 +92,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(Xs&& xs)
         { return hana::maximum(static_cast<Xs&&>(xs), hana::less); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_MAXIMUM_HPP
diff --git a/boost/hana/members.hpp b/boost/hana/members.hpp
index 13a520928836990f720afaef7ecc1698976b7363..c9f45714cf167122620346683457bed9c604abc0 100644
--- a/boost/hana/members.hpp
+++ b/boost/hana/members.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/transform.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Object>
     constexpr auto members_t::operator()(Object&& object) const {
@@ -60,6 +60,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_MEMBERS_HPP
diff --git a/boost/hana/min.hpp b/boost/hana/min.hpp
index f8c887147b681f61832293ee77d85562d27d9c0a..c5aa7e18bac2fc3ca1746cc18f625d8268397363 100644
--- a/boost/hana/min.hpp
+++ b/boost/hana/min.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/less.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr decltype(auto) min_t::operator()(X&& x, Y&& y) const {
@@ -53,6 +53,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_MIN_HPP
diff --git a/boost/hana/minimum.hpp b/boost/hana/minimum.hpp
index 8b6f41d8c8b65d7c1d2a06f55d31c0a8754168f6..df09d4c1890ce43ef251d36c2f973538cb2beebe 100644
--- a/boost/hana/minimum.hpp
+++ b/boost/hana/minimum.hpp
@@ -21,7 +21,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/less.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr decltype(auto) minimum_t::operator()(Xs&& xs) const {
@@ -92,6 +92,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(Xs&& xs)
         { return hana::minimum(static_cast<Xs&&>(xs), hana::less); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_MINIMUM_HPP
diff --git a/boost/hana/minus.hpp b/boost/hana/minus.hpp
index 007a3ec24e5abb6ce36484685c53e0b73535c8e1..bb98956eb03890d0aa5ed708d28bc251dbf3c79c 100644
--- a/boost/hana/minus.hpp
+++ b/boost/hana/minus.hpp
@@ -27,7 +27,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr decltype(auto) minus_t::operator()(X&& x, Y&& y) const {
@@ -109,6 +109,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(X const&, Y const&)
         { return hana::to<C>(detail::constant_from_minus<C, X, Y>{}); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_MINUS_HPP
diff --git a/boost/hana/mod.hpp b/boost/hana/mod.hpp
index f64b12f211cb4c8d56305a4997320bee66616bb8..31e958ae10ccee321097366a783cbd0f2d822a6c 100644
--- a/boost/hana/mod.hpp
+++ b/boost/hana/mod.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr decltype(auto) mod_t::operator()(X&& x, Y&& y) const {
@@ -102,6 +102,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(X const&, Y const&)
         { return hana::to<C>(detail::constant_from_mod<C, X, Y>{}); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_MOD_HPP
diff --git a/boost/hana/monadic_compose.hpp b/boost/hana/monadic_compose.hpp
index 064bfc24d33ae7a8503824997209f86d49c0af1e..14c535d85d71375459afbdc7e170e74a32baab84 100644
--- a/boost/hana/monadic_compose.hpp
+++ b/boost/hana/monadic_compose.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/partial.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace detail {
         struct monadic_compose_helper {
             template <typename F, typename G, typename X>
@@ -46,6 +46,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         );
     }
     //! @endcond
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_MONADIC_COMPOSE_HPP
diff --git a/boost/hana/monadic_fold_left.hpp b/boost/hana/monadic_fold_left.hpp
index 3a1e8142a7391b4f03f2df596b1e9c1f0553aafc..e77b5e00598ae84e674e470ac4a0840bb85acf19 100644
--- a/boost/hana/monadic_fold_left.hpp
+++ b/boost/hana/monadic_fold_left.hpp
@@ -26,7 +26,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename M>
     template <typename Xs, typename State, typename F>
@@ -131,6 +131,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return result;
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_MONADIC_FOLD_LEFT_HPP
diff --git a/boost/hana/monadic_fold_right.hpp b/boost/hana/monadic_fold_right.hpp
index c822d1d0038329b8e67cca71a07a5b6953cc6b37..42f05ef6d81d1456354f5b62bff9b1f6be1e7f33 100644
--- a/boost/hana/monadic_fold_right.hpp
+++ b/boost/hana/monadic_fold_right.hpp
@@ -26,7 +26,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename M>
     template <typename Xs, typename State, typename F>
@@ -130,6 +130,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return result;
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_MONADIC_FOLD_RIGHT_HPP
diff --git a/boost/hana/mult.hpp b/boost/hana/mult.hpp
index 9eb89a0cf25a6ab5dd9ea7ce50f9fa07a4d84251..c931f4191d0683a0b3f334d89d210cf5d43d0423 100644
--- a/boost/hana/mult.hpp
+++ b/boost/hana/mult.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr decltype(auto) mult_t::operator()(X&& x, Y&& y) const {
@@ -102,6 +102,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(X const&, Y const&)
         { return hana::to<C>(detail::constant_from_mult<C, X, Y>{}); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_MULT_HPP
diff --git a/boost/hana/negate.hpp b/boost/hana/negate.hpp
index 2b87e7d6a6f3757406e29cfbd7829539a6ee4137..cd339cfee15c8377d59d5468f7493377763fdd88 100644
--- a/boost/hana/negate.hpp
+++ b/boost/hana/negate.hpp
@@ -21,7 +21,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X>
     constexpr decltype(auto) negate_t::operator()(X&& x) const {
@@ -56,6 +56,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(X&& x)
         { return -static_cast<X&&>(x); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_NEGATE_HPP
diff --git a/boost/hana/none.hpp b/boost/hana/none.hpp
index 0d8d499dfe0b8e0820f1c8d96672e32570648ede..eba0a97053a874efac737ccebf771ebc94a09e8e 100644
--- a/boost/hana/none.hpp
+++ b/boost/hana/none.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/none_of.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr auto none_t::operator()(Xs&& xs) const {
@@ -43,6 +43,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr auto apply(Xs&& xs)
         { return hana::none_of(static_cast<Xs&&>(xs), hana::id); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_NONE_HPP
diff --git a/boost/hana/none_of.hpp b/boost/hana/none_of.hpp
index 4cf3ffd2d991cb66d1047d928f07cbc196ad43a3..78cc0a3268a099cb77e8579247b2b270e6b8b5cb 100644
--- a/boost/hana/none_of.hpp
+++ b/boost/hana/none_of.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/not.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred>
     constexpr auto none_of_t::operator()(Xs&& xs, Pred&& pred) const {
@@ -45,6 +45,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                            static_cast<Pred&&>(pred)));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_NONE_OF_HPP
diff --git a/boost/hana/not.hpp b/boost/hana/not.hpp
index 2475f637f1470db7850d308c07822a641bb03841..7f9ef3e12c2d321478ca20531290a149fc289274 100644
--- a/boost/hana/not.hpp
+++ b/boost/hana/not.hpp
@@ -22,7 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X>
     constexpr decltype(auto) not_t::operator()(X&& x) const {
@@ -70,6 +70,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr auto apply(Cond const&)
         { return hana::to<C>(detail::constant_from_not<C, Cond>{}); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_NOT_HPP
diff --git a/boost/hana/not_equal.hpp b/boost/hana/not_equal.hpp
index 099574bdd09d01d56fbb104ce012a2570acc1211..4c7055a2c0d407849d8e3f9fd6b7c0b19b707eb2 100644
--- a/boost/hana/not_equal.hpp
+++ b/boost/hana/not_equal.hpp
@@ -22,7 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/not.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr auto not_equal_t::operator()(X&& x, Y&& y) const {
@@ -54,6 +54,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                    hana::to<C>(static_cast<Y&&>(y)));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_NOT_EQUAL_HPP
diff --git a/boost/hana/one.hpp b/boost/hana/one.hpp
index df27b1e834f79e30488d97039d5539498ec705ef..de8758930aa904820b58f55e374599b52227b564 100644
--- a/boost/hana/one.hpp
+++ b/boost/hana/one.hpp
@@ -22,7 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename R>
     constexpr decltype(auto) one_t<R>::operator()() const {
@@ -74,6 +74,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply()
         { return hana::to<C>(detail::constant_from_one<C>{}); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ONE_HPP
diff --git a/boost/hana/optional.hpp b/boost/hana/optional.hpp
index b3fe78b6457d17bd799bbe9e78446a5a1e8d41c0..1ddeae7f97cf220ae6eba1670606ba0bc4d59b9d 100644
--- a/boost/hana/optional.hpp
+++ b/boost/hana/optional.hpp
@@ -41,7 +41,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //////////////////////////////////////////////////////////////////////////
     // optional<>
     //////////////////////////////////////////////////////////////////////////
@@ -412,6 +412,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr hana::false_ apply(hana::optional<> const&, Pred&&)
         { return {}; }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_OPTIONAL_HPP
diff --git a/boost/hana/or.hpp b/boost/hana/or.hpp
index b6aceac0c1b05e0c9d391da36da0dc7e487b6b80..79769f06053bd7b22748ed43e70a072ab978c2ad 100644
--- a/boost/hana/or.hpp
+++ b/boost/hana/or.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/if.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr decltype(auto) or_t::operator()(X&& x, Y&& y) const {
@@ -56,6 +56,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::if_(x, x, static_cast<Y&&>(y));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_OR_HPP
diff --git a/boost/hana/ordering.hpp b/boost/hana/ordering.hpp
index 2e8294a8927868f64c63ffc252ed9889ce219c48..a5b329f1edf9bb683edee9fc1593a1746a5b619d 100644
--- a/boost/hana/ordering.hpp
+++ b/boost/hana/ordering.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/less.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace detail {
         template <typename F>
         struct less_by {
@@ -39,6 +39,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         return detail::less_by<typename detail::decay<F>::type>{static_cast<F&&>(f)};
     }
     //! @endcond
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ORDERING_HPP
diff --git a/boost/hana/pair.hpp b/boost/hana/pair.hpp
index d88b8ad8d487aaa47633a82f7bc20e41203dbac9..6399f539bdb29ba3b740194205e6856f43a0865c 100644
--- a/boost/hana/pair.hpp
+++ b/boost/hana/pair.hpp
@@ -27,7 +27,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace detail {
         template <int> struct pix; // pair index
     }
@@ -206,6 +206,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_PAIR_HPP
diff --git a/boost/hana/partition.hpp b/boost/hana/partition.hpp
index e2131f4233f9bfd19a1368beb802e86a028d3883..cd18274f11dec9d2459ba0b493b16307da01d21e 100644
--- a/boost/hana/partition.hpp
+++ b/boost/hana/partition.hpp
@@ -28,7 +28,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred>
     constexpr auto partition_t::operator()(Xs&& xs, Pred&& pred) const {
@@ -111,6 +111,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_PARTITION_HPP
diff --git a/boost/hana/permutations.hpp b/boost/hana/permutations.hpp
index 601bd718899a4de946ee4db8d4fd1c29a9b3cead..fed370a250cad8214d3d470e19e6e11febb9117d 100644
--- a/boost/hana/permutations.hpp
+++ b/boost/hana/permutations.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr auto permutations_t::operator()(Xs&& xs) const {
@@ -73,6 +73,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return permutations_helper<N>(xs, std::make_index_sequence<total_perms>{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_PERMUTATIONS_HPP
diff --git a/boost/hana/plus.hpp b/boost/hana/plus.hpp
index bc916773a7f239d56bb2f3856363d01c384c1858..5275f64ebc2969f8c43359a155ff11e5b54976a3 100644
--- a/boost/hana/plus.hpp
+++ b/boost/hana/plus.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename Y>
     constexpr decltype(auto) plus_t::operator()(X&& x, Y&& y) const {
@@ -104,6 +104,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply(X const&, Y const&)
         { return hana::to<C>(detail::constant_from_plus<C, X, Y>{}); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_PLUS_HPP
diff --git a/boost/hana/power.hpp b/boost/hana/power.hpp
index 2a69ebfcaad14315f5145227794e2739e9665290..3453bb48314ea7c8252078ff67b2ec8fa32ca2b1 100644
--- a/boost/hana/power.hpp
+++ b/boost/hana/power.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename X, typename N>
     constexpr decltype(auto) power_t::operator()(X&& x, N const& n) const {
@@ -60,6 +60,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_POWER_HPP
diff --git a/boost/hana/prefix.hpp b/boost/hana/prefix.hpp
index e8b0c219478c7d6a6c6231f55be72299dcb13682..e7ad750508ddbf0a4edd3ee3cdfe5cc048354019 100644
--- a/boost/hana/prefix.hpp
+++ b/boost/hana/prefix.hpp
@@ -21,7 +21,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/lift.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pref>
     constexpr auto prefix_t::operator()(Xs&& xs, Pref&& pref) const {
@@ -47,6 +47,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                 hana::partial(hana::append, hana::lift<M>(static_cast<Z&&>(z))));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_PREFIX_HPP
diff --git a/boost/hana/prepend.hpp b/boost/hana/prepend.hpp
index 825d0b02f652efed11d43a4ace45734f9f38328f..508b064018203ce4b24548de49ab39a9176c9156 100644
--- a/boost/hana/prepend.hpp
+++ b/boost/hana/prepend.hpp
@@ -26,7 +26,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename X>
     constexpr auto prepend_t::operator()(Xs&& xs, X&& x) const {
@@ -69,6 +69,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                   std::make_index_sequence<N>{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_PREPEND_HPP
diff --git a/boost/hana/product.hpp b/boost/hana/product.hpp
index a419b15b403322ba28ecddb448bae459bfcae362..85600b8609192b37ebfe97c06ca97be47bd886e6 100644
--- a/boost/hana/product.hpp
+++ b/boost/hana/product.hpp
@@ -22,7 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/one.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename R>
     template <typename Xs>
@@ -51,6 +51,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::fold_left(static_cast<Xs&&>(xs), hana::one<R>(), hana::mult);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_PRODUCT_HPP
diff --git a/boost/hana/range.hpp b/boost/hana/range.hpp
index 96a9d02e6a9c837b1d5d74a258c0054244362471..fd48413485d15c79e748669019d931fc5afc03a8 100644
--- a/boost/hana/range.hpp
+++ b/boost/hana/range.hpp
@@ -44,7 +44,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //////////////////////////////////////////////////////////////////////////
     // range<>
     //////////////////////////////////////////////////////////////////////////
@@ -289,6 +289,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return range<T, from + n, to>{};
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_RANGE_HPP
diff --git a/boost/hana/remove.hpp b/boost/hana/remove.hpp
index 7d2925d38ef04a2e2adaa43983c49b7a9246dd36..a4730390cab0b72fd0b16a64ef776243d168b502 100644
--- a/boost/hana/remove.hpp
+++ b/boost/hana/remove.hpp
@@ -21,7 +21,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/not.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Value>
     constexpr auto remove_t::operator()(Xs&& xs, Value&& value) const {
@@ -49,6 +49,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                   hana::equal.to(static_cast<Value&&>(value))));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_REMOVE_HPP
diff --git a/boost/hana/remove_at.hpp b/boost/hana/remove_at.hpp
index 490ebe8c10583cc7a878aaeea69cd66a46b1b14f..dc21481d78c955e6376d0bc23e434ac707daafc9 100644
--- a/boost/hana/remove_at.hpp
+++ b/boost/hana/remove_at.hpp
@@ -25,7 +25,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename N>
     constexpr auto remove_at_t::operator()(Xs&& xs, N const& n) const {
@@ -81,6 +81,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         constexpr decltype(auto) operator()(Xs&& xs) const
         { return hana::remove_at(static_cast<Xs&&>(xs), hana::size_c<n>); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_REMOVE_AT_HPP
diff --git a/boost/hana/remove_if.hpp b/boost/hana/remove_if.hpp
index b379957f3bd74b11876c50a425da426bdf570d81..ad8a7b2be27144104a1603daf8fd7e98709abd7b 100644
--- a/boost/hana/remove_if.hpp
+++ b/boost/hana/remove_if.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/not.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred>
     constexpr auto remove_if_t::operator()(Xs&& xs, Pred&& pred) const {
@@ -47,6 +47,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                         hana::compose(hana::not_, static_cast<Pred&&>(pred)));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_REMOVE_IF_HPP
diff --git a/boost/hana/remove_range.hpp b/boost/hana/remove_range.hpp
index 5e46f8ae77deb8a1894eb876c68a287cf490460b..4a659192465501b09a4a30ac5bc8b594001d4ffb 100644
--- a/boost/hana/remove_range.hpp
+++ b/boost/hana/remove_range.hpp
@@ -25,7 +25,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename From, typename To>
     constexpr auto remove_range_t::operator()(Xs&& xs, From const& from, To const& to) const {
@@ -95,6 +95,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                       hana::size_c<to>);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_REMOVE_RANGE_HPP
diff --git a/boost/hana/repeat.hpp b/boost/hana/repeat.hpp
index 71854dadbe92f6a1cebd906d0abda4ef0b39507c..13e4a00624543b47d9744e77a32479672a9b1e1b 100644
--- a/boost/hana/repeat.hpp
+++ b/boost/hana/repeat.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename I, bool condition>
     struct repeat_impl<I, when<condition>> : default_ {
         template <typename F, std::size_t ...i>
@@ -53,6 +53,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         return Repeat::apply(n, static_cast<F&&>(f));
     }
     //! @endcond
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_REPEAT_HPP
diff --git a/boost/hana/replace.hpp b/boost/hana/replace.hpp
index f797f6de2a62f0420680454503ab896eab685fb7..92e03f2dd784fc7edbbb17007481b81fa291a115 100644
--- a/boost/hana/replace.hpp
+++ b/boost/hana/replace.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/replace_if.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename OldVal, typename NewVal>
     constexpr auto replace_t::operator()(Xs&& xs, OldVal&& oldval, NewVal&& newval) const {
@@ -51,6 +51,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_REPLACE_HPP
diff --git a/boost/hana/replace_if.hpp b/boost/hana/replace_if.hpp
index 026dd61354d726e4d8dd2c8ba5f033f3f7c02926..937398077d8d4fbf6aceef8d5a3362653f97beaa 100644
--- a/boost/hana/replace_if.hpp
+++ b/boost/hana/replace_if.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/always.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred, typename Value>
     constexpr auto replace_if_t::operator()(Xs&& xs, Pred&& pred, Value&& value) const {
@@ -49,6 +49,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_REPLACE_IF_HPP
diff --git a/boost/hana/replicate.hpp b/boost/hana/replicate.hpp
index 3d82712d4fb1577539427145b009ed13d957f826..77a50fc26334d5fc61fc365aa83aab10e86a86a7 100644
--- a/boost/hana/replicate.hpp
+++ b/boost/hana/replicate.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename M>
     template <typename X, typename N>
@@ -67,6 +67,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                     std::make_index_sequence<n>{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_REPLICATE_HPP
diff --git a/boost/hana/reverse.hpp b/boost/hana/reverse.hpp
index 3e4126963fc4e7fe3a6b9a47e0022e7068d5df35..487e1f344c3462a644ce17c0384cd3a38b054e81 100644
--- a/boost/hana/reverse.hpp
+++ b/boost/hana/reverse.hpp
@@ -23,7 +23,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr auto reverse_t::operator()(Xs&& xs) const {
@@ -56,6 +56,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return reverse_helper(static_cast<Xs&&>(xs), std::make_index_sequence<N>{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_REVERSE_HPP
diff --git a/boost/hana/reverse_fold.hpp b/boost/hana/reverse_fold.hpp
index 5735a423dd5b6891399e8369288dedcecb0cbfe3..0a43b332c6c4961322f440dff157a40fb79f718c 100644
--- a/boost/hana/reverse_fold.hpp
+++ b/boost/hana/reverse_fold.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/flip.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename S, typename F>
     constexpr decltype(auto) reverse_fold_t::operator()(Xs&& xs, S&& s, F&& f) const {
@@ -32,6 +32,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                 hana::flip(static_cast<F&&>(f)));
     }
     //! @endcond
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_REVERSE_FOLD_HPP
diff --git a/boost/hana/scan_left.hpp b/boost/hana/scan_left.hpp
index 2ce4eb5d9d68e110271104f7da0a2b1d12bf8d90..6b40a20f772a47beee02f15e46379f9710b70818 100644
--- a/boost/hana/scan_left.hpp
+++ b/boost/hana/scan_left.hpp
@@ -25,7 +25,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename F>
     constexpr auto scan_left_t::operator()(Xs&& xs, F const& f) const {
@@ -128,6 +128,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                               f, std::make_index_sequence<Len>{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_SCAN_LEFT_HPP
diff --git a/boost/hana/scan_right.hpp b/boost/hana/scan_right.hpp
index a24eb145caa38e06ec623e9f885c9c9160bf2d28..86a27c4d43a3348f015238dfd5c784a88622a66b 100644
--- a/boost/hana/scan_right.hpp
+++ b/boost/hana/scan_right.hpp
@@ -26,7 +26,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename F>
     constexpr auto scan_right_t::operator()(Xs&& xs, F const& f) const {
@@ -125,6 +125,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                                f, std::make_index_sequence<Len>{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_SCAN_RIGHT_HPP
diff --git a/boost/hana/second.hpp b/boost/hana/second.hpp
index f17e7a67bf789301ec77edd55fc75bfc2f6446cd..d88c58a0a177d309ae31e1726c85d1c82069d241 100644
--- a/boost/hana/second.hpp
+++ b/boost/hana/second.hpp
@@ -17,7 +17,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/dispatch.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Pair>
     constexpr decltype(auto) second_t::operator()(Pair&& pair) const {
@@ -40,6 +40,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         template <typename ...Args>
         static constexpr auto apply(Args&& ...) = delete;
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_SECOND_HPP
diff --git a/boost/hana/set.hpp b/boost/hana/set.hpp
index 53b4e8ec745f3157dd0e8ac543c292bf26348db2..ab7a56ddb0a3ed242169f752c425fa94e526eec2 100644
--- a/boost/hana/set.hpp
+++ b/boost/hana/set.hpp
@@ -50,7 +50,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //////////////////////////////////////////////////////////////////////////
     // set
     //////////////////////////////////////////////////////////////////////////
@@ -318,6 +318,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                    hana::erase_key);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_SET_HPP
diff --git a/boost/hana/slice.hpp b/boost/hana/slice.hpp
index 2cc4c7209d8914c8ee0b824c82fd7cde93c12061..35c84a5373e5e35442af529879bcbef317425ee5 100644
--- a/boost/hana/slice.hpp
+++ b/boost/hana/slice.hpp
@@ -25,7 +25,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Indices>
     constexpr auto slice_t::operator()(Xs&& xs, Indices&& indices) const {
@@ -94,6 +94,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                hana::range_c<std::size_t, from, to>);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_SLICE_HPP
diff --git a/boost/hana/sort.hpp b/boost/hana/sort.hpp
index 0e42b38506af635588b3829d1b610b87775d02b6..314ad1cd36528690d2ff54a798720cde7c67049b 100644
--- a/boost/hana/sort.hpp
+++ b/boost/hana/sort.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility> // std::declval, std::index_sequence
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Predicate>
     constexpr auto sort_t::operator()(Xs&& xs, Predicate&& pred) const {
@@ -268,6 +268,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr auto apply(Xs&& xs)
         { return sort_impl::apply(static_cast<Xs&&>(xs), hana::less); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_SORT_HPP
diff --git a/boost/hana/span.hpp b/boost/hana/span.hpp
index 2219749b05980245dd8239afc9bd8a51d27f46bb..e38300206e48999e2e6e9f1ebc35bd53b71d1959 100644
--- a/boost/hana/span.hpp
+++ b/boost/hana/span.hpp
@@ -27,7 +27,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred>
     constexpr auto span_t::operator()(Xs&& xs, Pred&& pred) const {
@@ -70,6 +70,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                std::make_index_sequence<N - breakpoint>{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_SPAN_HPP
diff --git a/boost/hana/string.hpp b/boost/hana/string.hpp
index fcdce266d741c6ffb69f662e9b04cb23cb4aef70..cd0f2fc46514c18a03bb3adf61e88f78902e5dd1 100644
--- a/boost/hana/string.hpp
+++ b/boost/hana/string.hpp
@@ -46,7 +46,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //////////////////////////////////////////////////////////////////////////
     // string<>
     //////////////////////////////////////////////////////////////////////////
@@ -344,6 +344,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::type_c<String>;
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_STRING_HPP
diff --git a/boost/hana/suffix.hpp b/boost/hana/suffix.hpp
index 68a344db6e37594a49183ae049bb926834eaee25..23cdf4375641ed5166d84c6bc5719ba33b3e4923 100644
--- a/boost/hana/suffix.hpp
+++ b/boost/hana/suffix.hpp
@@ -21,7 +21,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/prepend.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Sfx>
     constexpr auto suffix_t::operator()(Xs&& xs, Sfx&& sfx) const {
@@ -47,6 +47,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                 hana::partial(hana::prepend, hana::lift<M>(static_cast<Z&&>(z))));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_SUFFIX_HPP
diff --git a/boost/hana/sum.hpp b/boost/hana/sum.hpp
index 2b6f6b8219b8dce156f710a0690c504031fd1c2d..b940028ca4a0da281ef069ecf35f71e42a0bfcdf 100644
--- a/boost/hana/sum.hpp
+++ b/boost/hana/sum.hpp
@@ -22,7 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/zero.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename M>
     template <typename Xs>
@@ -51,6 +51,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::fold_left(static_cast<Xs&&>(xs), hana::zero<M>(), hana::plus);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_SUM_HPP
diff --git a/boost/hana/symmetric_difference.hpp b/boost/hana/symmetric_difference.hpp
index 1ca56d30195cc3354fa5448ec60c722b9cfea863..90047586f540e13c5b3eeab4781bcd62994253c1 100644
--- a/boost/hana/symmetric_difference.hpp
+++ b/boost/hana/symmetric_difference.hpp
@@ -18,7 +18,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/union.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Ys>
     constexpr auto symmetric_difference_t::operator()(Xs&& xs, Ys&& ys) const {
@@ -41,6 +41,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_SYMMETRIC_DIFFERENCE_HPP
diff --git a/boost/hana/take_back.hpp b/boost/hana/take_back.hpp
index 4d9c39974f5fa7546f49e62dff1c2581b382f9b2..d8884cc2528246b0d7959c1914f1f116635d48cf 100644
--- a/boost/hana/take_back.hpp
+++ b/boost/hana/take_back.hpp
@@ -25,7 +25,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename N>
     constexpr auto take_back_t::operator()(Xs&& xs, N const& n) const {
@@ -71,6 +71,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::take_back(static_cast<Xs&&>(xs), hana::size_c<n>);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_TAKE_BACK_HPP
diff --git a/boost/hana/take_front.hpp b/boost/hana/take_front.hpp
index b32fbb6e508eda8de55acc1bb9d2b6960cd38c41..e2ba532196529fd9b0ff4a896d707c4fa9e5eb4a 100644
--- a/boost/hana/take_front.hpp
+++ b/boost/hana/take_front.hpp
@@ -25,7 +25,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename N>
     constexpr auto take_front_t::operator()(Xs&& xs, N const& n) const {
@@ -70,6 +70,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::take_front(static_cast<Xs&&>(xs), hana::size_c<n>);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_TAKE_FRONT_HPP
diff --git a/boost/hana/take_while.hpp b/boost/hana/take_while.hpp
index 392459dca77153fe403e72e7b81f7a11b8d88e06..5cda8ca4136af8984778959c4baf4397e7e23beb 100644
--- a/boost/hana/take_while.hpp
+++ b/boost/hana/take_while.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/unpack.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Pred>
     constexpr auto take_while_t::operator()(Xs&& xs, Pred&& pred) const {
@@ -50,6 +50,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::take_front(static_cast<Xs&&>(xs), FirstUnsatisfied{});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_TAKE_WHILE_HPP
diff --git a/boost/hana/tap.hpp b/boost/hana/tap.hpp
index 332f9ff83d555875915069bf52e64b4c9095c715..483842493e3873a59c9260694cfe97d7cf8f7282 100644
--- a/boost/hana/tap.hpp
+++ b/boost/hana/tap.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/lift.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename M>
     template <typename F>
@@ -54,6 +54,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr auto apply(F&& f)
         { return hana::partial(detail::tap_helper<M>{}, static_cast<F&&>(f)); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_TAP_HPP
diff --git a/boost/hana/then.hpp b/boost/hana/then.hpp
index b6d74cfcf4e544cfd6bf5bb08d95cde16f098a72..e4468a07f6cb6ce926c6a4c93de7f92562cf03d7 100644
--- a/boost/hana/then.hpp
+++ b/boost/hana/then.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/always.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Before, typename Xs>
     constexpr decltype(auto) then_t::operator()(Before&& before, Xs&& xs) const {
@@ -50,6 +50,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                hana::always(static_cast<Ys&&>(ys)));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_THEN_HPP
diff --git a/boost/hana/traits.hpp b/boost/hana/traits.hpp
index de207d3c986a4cfb6c0323fb39c55e0b3c0eb5cd..69a92000df7492d6064e86da1eb861a6c951054e 100644
--- a/boost/hana/traits.hpp
+++ b/boost/hana/traits.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN namespace traits {
+namespace boost { namespace hana { namespace traits {
     namespace detail {
         // We use this instead of hana::integral because we want to return
         // hana::integral_constants instead of std::integral_constants.
@@ -37,85 +37,87 @@ BOOST_HANA_NAMESPACE_BEGIN namespace traits {
     // Type properties
     ///////////////////////
     // Primary type categories
-    constexpr auto is_void = detail::hana_trait<std::is_void>{};
-    constexpr auto is_null_pointer = detail::hana_trait<std::is_null_pointer>{};
-    constexpr auto is_integral = detail::hana_trait<std::is_integral>{};
-    constexpr auto is_floating_point = detail::hana_trait<std::is_floating_point>{};
-    constexpr auto is_array = detail::hana_trait<std::is_array>{};
-    constexpr auto is_enum = detail::hana_trait<std::is_enum>{};
-    constexpr auto is_union = detail::hana_trait<std::is_union>{};
-    constexpr auto is_class = detail::hana_trait<std::is_class>{};
-    constexpr auto is_function = detail::hana_trait<std::is_function>{};
-    constexpr auto is_pointer = detail::hana_trait<std::is_pointer>{};
-    constexpr auto is_lvalue_reference = detail::hana_trait<std::is_lvalue_reference>{};
-    constexpr auto is_rvalue_reference = detail::hana_trait<std::is_rvalue_reference>{};
-    constexpr auto is_member_object_pointer = detail::hana_trait<std::is_member_object_pointer>{};
-    constexpr auto is_member_function_pointer = detail::hana_trait<std::is_member_function_pointer>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_void = detail::hana_trait<std::is_void>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_null_pointer = detail::hana_trait<std::is_null_pointer>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_integral = detail::hana_trait<std::is_integral>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_floating_point = detail::hana_trait<std::is_floating_point>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_array = detail::hana_trait<std::is_array>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_enum = detail::hana_trait<std::is_enum>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_union = detail::hana_trait<std::is_union>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_class = detail::hana_trait<std::is_class>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_function = detail::hana_trait<std::is_function>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_pointer = detail::hana_trait<std::is_pointer>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_lvalue_reference = detail::hana_trait<std::is_lvalue_reference>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_rvalue_reference = detail::hana_trait<std::is_rvalue_reference>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_member_object_pointer = detail::hana_trait<std::is_member_object_pointer>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_member_function_pointer = detail::hana_trait<std::is_member_function_pointer>{};
 
     // Composite type categories
-    constexpr auto is_fundamental = detail::hana_trait<std::is_fundamental>{};
-    constexpr auto is_arithmetic = detail::hana_trait<std::is_arithmetic>{};
-    constexpr auto is_scalar = detail::hana_trait<std::is_scalar>{};
-    constexpr auto is_object = detail::hana_trait<std::is_object>{};
-    constexpr auto is_compound = detail::hana_trait<std::is_compound>{};
-    constexpr auto is_reference = detail::hana_trait<std::is_reference>{};
-    constexpr auto is_member_pointer = detail::hana_trait<std::is_member_pointer>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_fundamental = detail::hana_trait<std::is_fundamental>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_arithmetic = detail::hana_trait<std::is_arithmetic>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_scalar = detail::hana_trait<std::is_scalar>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_object = detail::hana_trait<std::is_object>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_compound = detail::hana_trait<std::is_compound>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_reference = detail::hana_trait<std::is_reference>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_member_pointer = detail::hana_trait<std::is_member_pointer>{};
 
     // Type properties
-    constexpr auto is_const = detail::hana_trait<std::is_const>{};
-    constexpr auto is_volatile = detail::hana_trait<std::is_volatile>{};
-    constexpr auto is_trivial = detail::hana_trait<std::is_trivial>{};
-    constexpr auto is_trivially_copyable = detail::hana_trait<std::is_trivially_copyable>{};
-    constexpr auto is_standard_layout = detail::hana_trait<std::is_standard_layout>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_const = detail::hana_trait<std::is_const>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_volatile = detail::hana_trait<std::is_volatile>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_trivial = detail::hana_trait<std::is_trivial>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_trivially_copyable = detail::hana_trait<std::is_trivially_copyable>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_standard_layout = detail::hana_trait<std::is_standard_layout>{};
 #if __cplusplus < 202002L
-    constexpr auto is_pod = detail::hana_trait<std::is_pod>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_pod = detail::hana_trait<std::is_pod>{};
 #endif
-    constexpr auto is_literal_type = detail::hana_trait<std::is_literal_type>{};
-    constexpr auto is_empty = detail::hana_trait<std::is_empty>{};
-    constexpr auto is_polymorphic = detail::hana_trait<std::is_polymorphic>{};
-    constexpr auto is_abstract = detail::hana_trait<std::is_abstract>{};
-    constexpr auto is_signed = detail::hana_trait<std::is_signed>{};
-    constexpr auto is_unsigned = detail::hana_trait<std::is_unsigned>{};
+#if __cplusplus < 201703L
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_literal_type = detail::hana_trait<std::is_literal_type>{};
+#endif
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_empty = detail::hana_trait<std::is_empty>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_polymorphic = detail::hana_trait<std::is_polymorphic>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_abstract = detail::hana_trait<std::is_abstract>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_signed = detail::hana_trait<std::is_signed>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_unsigned = detail::hana_trait<std::is_unsigned>{};
 
     // Supported operations
-    constexpr auto is_constructible = detail::hana_trait<std::is_constructible>{};
-    constexpr auto is_trivially_constructible = detail::hana_trait<std::is_trivially_constructible>{};
-    constexpr auto is_nothrow_constructible = detail::hana_trait<std::is_nothrow_constructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_constructible = detail::hana_trait<std::is_constructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_trivially_constructible = detail::hana_trait<std::is_trivially_constructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_nothrow_constructible = detail::hana_trait<std::is_nothrow_constructible>{};
 
-    constexpr auto is_default_constructible = detail::hana_trait<std::is_default_constructible>{};
-    constexpr auto is_trivially_default_constructible = detail::hana_trait<std::is_trivially_default_constructible>{};
-    constexpr auto is_nothrow_default_constructible = detail::hana_trait<std::is_nothrow_default_constructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_default_constructible = detail::hana_trait<std::is_default_constructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_trivially_default_constructible = detail::hana_trait<std::is_trivially_default_constructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_nothrow_default_constructible = detail::hana_trait<std::is_nothrow_default_constructible>{};
 
-    constexpr auto is_copy_constructible = detail::hana_trait<std::is_copy_constructible>{};
-    constexpr auto is_trivially_copy_constructible = detail::hana_trait<std::is_trivially_copy_constructible>{};
-    constexpr auto is_nothrow_copy_constructible = detail::hana_trait<std::is_nothrow_copy_constructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_copy_constructible = detail::hana_trait<std::is_copy_constructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_trivially_copy_constructible = detail::hana_trait<std::is_trivially_copy_constructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_nothrow_copy_constructible = detail::hana_trait<std::is_nothrow_copy_constructible>{};
 
-    constexpr auto is_move_constructible = detail::hana_trait<std::is_move_constructible>{};
-    constexpr auto is_trivially_move_constructible = detail::hana_trait<std::is_trivially_move_constructible>{};
-    constexpr auto is_nothrow_move_constructible = detail::hana_trait<std::is_nothrow_move_constructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_move_constructible = detail::hana_trait<std::is_move_constructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_trivially_move_constructible = detail::hana_trait<std::is_trivially_move_constructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_nothrow_move_constructible = detail::hana_trait<std::is_nothrow_move_constructible>{};
 
-    constexpr auto is_assignable = detail::hana_trait<std::is_assignable>{};
-    constexpr auto is_trivially_assignable = detail::hana_trait<std::is_trivially_assignable>{};
-    constexpr auto is_nothrow_assignable = detail::hana_trait<std::is_nothrow_assignable>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_assignable = detail::hana_trait<std::is_assignable>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_trivially_assignable = detail::hana_trait<std::is_trivially_assignable>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_nothrow_assignable = detail::hana_trait<std::is_nothrow_assignable>{};
 
-    constexpr auto is_copy_assignable = detail::hana_trait<std::is_copy_assignable>{};
-    constexpr auto is_trivially_copy_assignable = detail::hana_trait<std::is_trivially_copy_assignable>{};
-    constexpr auto is_nothrow_copy_assignable = detail::hana_trait<std::is_nothrow_copy_assignable>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_copy_assignable = detail::hana_trait<std::is_copy_assignable>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_trivially_copy_assignable = detail::hana_trait<std::is_trivially_copy_assignable>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_nothrow_copy_assignable = detail::hana_trait<std::is_nothrow_copy_assignable>{};
 
-    constexpr auto is_move_assignable = detail::hana_trait<std::is_move_assignable>{};
-    constexpr auto is_trivially_move_assignable = detail::hana_trait<std::is_trivially_move_assignable>{};
-    constexpr auto is_nothrow_move_assignable = detail::hana_trait<std::is_nothrow_move_assignable>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_move_assignable = detail::hana_trait<std::is_move_assignable>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_trivially_move_assignable = detail::hana_trait<std::is_trivially_move_assignable>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_nothrow_move_assignable = detail::hana_trait<std::is_nothrow_move_assignable>{};
 
-    constexpr auto is_destructible = detail::hana_trait<std::is_destructible>{};
-    constexpr auto is_trivially_destructible = detail::hana_trait<std::is_trivially_destructible>{};
-    constexpr auto is_nothrow_destructible = detail::hana_trait<std::is_nothrow_destructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_destructible = detail::hana_trait<std::is_destructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_trivially_destructible = detail::hana_trait<std::is_trivially_destructible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_nothrow_destructible = detail::hana_trait<std::is_nothrow_destructible>{};
 
-    constexpr auto has_virtual_destructor = detail::hana_trait<std::has_virtual_destructor>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto has_virtual_destructor = detail::hana_trait<std::has_virtual_destructor>{};
 
     // Property queries
-    constexpr auto alignment_of = detail::hana_trait<std::alignment_of>{};
-    constexpr auto rank = detail::hana_trait<std::rank>{};
-    constexpr struct extent_t {
+    BOOST_HANA_INLINE_VARIABLE constexpr auto alignment_of = detail::hana_trait<std::alignment_of>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto rank = detail::hana_trait<std::rank>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr struct extent_t {
         template <typename T, typename N>
         constexpr auto operator()(T const&, N const&) const {
             constexpr unsigned n = N::value;
@@ -129,41 +131,41 @@ BOOST_HANA_NAMESPACE_BEGIN namespace traits {
     } extent{};
 
     // Type relationships
-    constexpr auto is_same = detail::hana_trait<std::is_same>{};
-    constexpr auto is_base_of = detail::hana_trait<std::is_base_of>{};
-    constexpr auto is_convertible = detail::hana_trait<std::is_convertible>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_same = detail::hana_trait<std::is_same>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_base_of = detail::hana_trait<std::is_base_of>{};
+    BOOST_HANA_INLINE_VARIABLE constexpr auto is_convertible = detail::hana_trait<std::is_convertible>{};
 
     ///////////////////////
     // Type modifications
     ///////////////////////
     // Const-volatility specifiers
-    constexpr auto remove_cv = metafunction<std::remove_cv>;
-    constexpr auto remove_const = metafunction<std::remove_const>;
-    constexpr auto remove_volatile = metafunction<std::remove_volatile>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto remove_cv = metafunction<std::remove_cv>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto remove_const = metafunction<std::remove_const>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto remove_volatile = metafunction<std::remove_volatile>;
 
-    constexpr auto add_cv = metafunction<std::add_cv>;
-    constexpr auto add_const = metafunction<std::add_const>;
-    constexpr auto add_volatile = metafunction<std::add_volatile>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto add_cv = metafunction<std::add_cv>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto add_const = metafunction<std::add_const>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto add_volatile = metafunction<std::add_volatile>;
 
     // References
-    constexpr auto remove_reference = metafunction<std::remove_reference>;
-    constexpr auto add_lvalue_reference = metafunction<std::add_lvalue_reference>;
-    constexpr auto add_rvalue_reference = metafunction<std::add_rvalue_reference>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto remove_reference = metafunction<std::remove_reference>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto add_lvalue_reference = metafunction<std::add_lvalue_reference>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto add_rvalue_reference = metafunction<std::add_rvalue_reference>;
 
     // Pointers
-    constexpr auto remove_pointer = metafunction<std::remove_pointer>;
-    constexpr auto add_pointer = metafunction<std::add_pointer>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto remove_pointer = metafunction<std::remove_pointer>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto add_pointer = metafunction<std::add_pointer>;
 
     // Sign modifiers
-    constexpr auto make_signed = metafunction<std::make_signed>;
-    constexpr auto make_unsigned = metafunction<std::make_unsigned>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto make_signed = metafunction<std::make_signed>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto make_unsigned = metafunction<std::make_unsigned>;
 
     // Arrays
-    constexpr auto remove_extent = metafunction<std::remove_extent>;
-    constexpr auto remove_all_extents = metafunction<std::remove_all_extents>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto remove_extent = metafunction<std::remove_extent>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto remove_all_extents = metafunction<std::remove_all_extents>;
 
     // Miscellaneous transformations
-    constexpr struct aligned_storage_t {
+    BOOST_HANA_INLINE_VARIABLE constexpr struct aligned_storage_t {
         template <typename Len, typename Align>
         constexpr auto operator()(Len const&, Align const&) const {
             constexpr std::size_t len = Len::value;
@@ -180,7 +182,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace traits {
         }
     } aligned_storage{};
 
-    constexpr struct aligned_union_t {
+    BOOST_HANA_INLINE_VARIABLE constexpr struct aligned_union_t {
         template <typename Len, typename ...T>
         constexpr auto operator()(Len const&, T const&...) const {
             constexpr std::size_t len = Len::value;
@@ -189,13 +191,13 @@ BOOST_HANA_NAMESPACE_BEGIN namespace traits {
         }
     } aligned_union{};
 
-    constexpr auto decay = metafunction<std::decay>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto decay = metafunction<std::decay>;
     // enable_if
     // disable_if
     // conditional
 
-    constexpr auto common_type = metafunction<std::common_type>;
-    constexpr auto underlying_type = metafunction<std::underlying_type>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto common_type = metafunction<std::common_type>;
+    BOOST_HANA_INLINE_VARIABLE constexpr auto underlying_type = metafunction<std::underlying_type>;
 
 
     ///////////////////////
@@ -208,7 +210,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace traits {
         >::type operator()(T const&) const;
     };
 
-    constexpr declval_t declval{};
-} BOOST_HANA_NAMESPACE_END
+    BOOST_HANA_INLINE_VARIABLE constexpr declval_t declval{};
+} }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_TRAITS_HPP
diff --git a/boost/hana/transform.hpp b/boost/hana/transform.hpp
index 7c68731e2d4f86c71f875a9ea1b375dbb9a8e642..bbdbf9c8cc3ddb872a11d15482497e6a9d667c49 100644
--- a/boost/hana/transform.hpp
+++ b/boost/hana/transform.hpp
@@ -23,7 +23,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/unpack.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename F>
     constexpr auto transform_t::operator()(Xs&& xs, F&& f) const {
@@ -71,6 +71,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                 transformer<decltype(&f)>{&f});
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_TRANSFORM_HPP
diff --git a/boost/hana/tuple.hpp b/boost/hana/tuple.hpp
index a81ab9da69c7d9e2ac99ddf16586200aa137b252..09e3e3ce3c6cbfca95e3662018a87807c90d5927 100644
--- a/boost/hana/tuple.hpp
+++ b/boost/hana/tuple.hpp
@@ -40,7 +40,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     namespace detail {
         template <typename Xs, typename Ys, std::size_t ...n>
         constexpr void assign(Xs& xs, Ys&& ys, std::index_sequence<n...>) {
@@ -315,6 +315,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         tuple<typename detail::decay<Xs>::type...> apply(Xs&& ...xs)
         { return {static_cast<Xs&&>(xs)...}; }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_TUPLE_HPP
diff --git a/boost/hana/type.hpp b/boost/hana/type.hpp
index b1d3e2a308a661bf2841e81c3cf881b455c3908a..60cb3688f8674f144deb903cfaeb861076298cc8 100644
--- a/boost/hana/type.hpp
+++ b/boost/hana/type.hpp
@@ -27,7 +27,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //////////////////////////////////////////////////////////////////////////
     // basic_type
     //////////////////////////////////////////////////////////////////////////
@@ -279,6 +279,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr T apply(T const& t)
         { return t; }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_TYPE_HPP
diff --git a/boost/hana/unfold_left.hpp b/boost/hana/unfold_left.hpp
index d058ac06b26c43bd17966744c8245ac4ab15de75..a3914eb4dc48b921cc0928e790503f6c69839bda 100644
--- a/boost/hana/unfold_left.hpp
+++ b/boost/hana/unfold_left.hpp
@@ -23,7 +23,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/second.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename S>
     struct unfold_left_t {
@@ -66,6 +66,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_UNFOLD_LEFT_HPP
diff --git a/boost/hana/unfold_right.hpp b/boost/hana/unfold_right.hpp
index f9917bd7e192053944fd457f5821b3e03695bb36..5c52d093651f36f6115bee9eba5a882450810634 100644
--- a/boost/hana/unfold_right.hpp
+++ b/boost/hana/unfold_right.hpp
@@ -23,7 +23,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/second.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename S>
     struct unfold_right_t {
@@ -66,6 +66,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_UNFOLD_RIGHT_HPP
diff --git a/boost/hana/union.hpp b/boost/hana/union.hpp
index d7bb4403bff52a5aff5c0d6a40daefc82402eaf4..45c4e66f66f7f0627945a770a38ec3a7e0ebcfd1 100644
--- a/boost/hana/union.hpp
+++ b/boost/hana/union.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/dispatch.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename Ys>
     constexpr auto union_t::operator()(Xs&& xs, Ys&& ys) const {
@@ -34,6 +34,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         template <typename ...Args>
         static constexpr auto apply(Args&& ...) = delete;
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_UNION_HPP
diff --git a/boost/hana/unique.hpp b/boost/hana/unique.hpp
index 9485c332f02f881f8a49b27474f4b2663ab292ae..7649f5aa4dfd3845994d049df213ca4d0c1533c1 100644
--- a/boost/hana/unique.hpp
+++ b/boost/hana/unique.hpp
@@ -22,7 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/transform.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs>
     constexpr auto unique_t::operator()(Xs&& xs) const {
@@ -70,6 +70,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr auto apply(Xs&& xs)
         { return unique_impl::apply(static_cast<Xs&&>(xs), hana::equal); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_UNIQUE_HPP
diff --git a/boost/hana/unpack.hpp b/boost/hana/unpack.hpp
index 485821ea7a2fdbd82e30988d815e953edb42bea5..b2f01f8feb14fc23ad44ff91c6256e3dddfdf194 100644
--- a/boost/hana/unpack.hpp
+++ b/boost/hana/unpack.hpp
@@ -30,7 +30,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename F>
     constexpr decltype(auto) unpack_t::operator()(Xs&& xs, F&& f) const {
@@ -136,6 +136,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                               static_cast<Udt&&>(udt)));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_UNPACK_HPP
diff --git a/boost/hana/value.hpp b/boost/hana/value.hpp
index 52d05818535bb6a8ba3cb5090489b63787676e37..237b5c8eba363017f58bb6e777d57a2608569374 100644
--- a/boost/hana/value.hpp
+++ b/boost/hana/value.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     template <typename C, bool condition>
     struct value_impl<C, when<condition>> : default_ {
         template <typename ...Args>
@@ -51,6 +51,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr auto apply()
         { return C::value; }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_VALUE_HPP
diff --git a/boost/hana/version.hpp b/boost/hana/version.hpp
index 282070d06270a3010ee39f43c5fbb9d3cea76eb7..d10b6796c1f18efcec27cb139ef8bbd6ab956b36 100644
--- a/boost/hana/version.hpp
+++ b/boost/hana/version.hpp
@@ -28,7 +28,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 //! @ingroup group-config
 //! Macro expanding to the patch level of the library, i.e. the `z` in `x.y.z`.
-#define BOOST_HANA_PATCH_VERSION 0
+#define BOOST_HANA_PATCH_VERSION 1
 
 //! @ingroup group-config
 //! Macro expanding to the full version of the library, in hexadecimal
diff --git a/boost/hana/while.hpp b/boost/hana/while.hpp
index 312494daf51e8af23e1bb6111763ee9d54f51f69..a0e6a917f617154ff740f5408234e10ffef401a8 100644
--- a/boost/hana/while.hpp
+++ b/boost/hana/while.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Pred, typename State, typename F>
     constexpr decltype(auto) while_t::operator()(Pred&& pred, State&& state, F&& f) const {
@@ -112,6 +112,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                 static_cast<F&&>(f));
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_WHILE_HPP
diff --git a/boost/hana/zero.hpp b/boost/hana/zero.hpp
index 317023a1b3af7b51d610e30afe4885c23bb78f12..b5e5f8fa67bbb7e973d9707264f986548d49a5c4 100644
--- a/boost/hana/zero.hpp
+++ b/boost/hana/zero.hpp
@@ -22,7 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <type_traits>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename M>
     constexpr decltype(auto) zero_t<M>::operator()() const {
@@ -76,6 +76,6 @@ BOOST_HANA_NAMESPACE_BEGIN
         static constexpr decltype(auto) apply()
         { return hana::to<C>(detail::constant_from_zero<C>{}); }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ZERO_HPP
diff --git a/boost/hana/zip.hpp b/boost/hana/zip.hpp
index d18f3ef5e7c1f6e6c99cf15f9e2b6422641f114d..61fb67bf8114a4e48d90c1a4fac82e36343ce464 100644
--- a/boost/hana/zip.hpp
+++ b/boost/hana/zip.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/zip_with.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename ...Ys>
     constexpr auto zip_t::operator()(Xs&& xs, Ys&& ...ys) const {
@@ -45,6 +45,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             return hana::zip_with(hana::make_tuple, static_cast<Xs&&>(xs)...);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ZIP_HPP
diff --git a/boost/hana/zip_shortest.hpp b/boost/hana/zip_shortest.hpp
index 761ca188c511911ef1f405bcd42ae047c9860f5c..d12754d3c96b88a8081fb69412a9ed047e97dea9 100644
--- a/boost/hana/zip_shortest.hpp
+++ b/boost/hana/zip_shortest.hpp
@@ -20,7 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/zip_shortest_with.hpp>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename Xs, typename ...Ys>
     constexpr auto zip_shortest_t::operator()(Xs&& xs, Ys&& ...ys) const {
@@ -46,6 +46,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                                            static_cast<Xs&&>(xs)...);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ZIP_SHORTEST_HPP
diff --git a/boost/hana/zip_shortest_with.hpp b/boost/hana/zip_shortest_with.hpp
index fc43f35239373a81ed84e060b4e2d77ff0c54947..4371e4dc3152e77098ed18b30f95a3ec8deddd56 100644
--- a/boost/hana/zip_shortest_with.hpp
+++ b/boost/hana/zip_shortest_with.hpp
@@ -25,7 +25,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <cstddef>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename F, typename Xs, typename ...Ys>
     constexpr auto
@@ -59,6 +59,6 @@ BOOST_HANA_NAMESPACE_BEGIN
             );
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ZIP_SHORTEST_WITH_HPP
diff --git a/boost/hana/zip_with.hpp b/boost/hana/zip_with.hpp
index 8a5e153fe0b93010571c41b6d8eb1430feae88ae..685bd9f2eabd5c4eaa3eb7431e95a965d9a9725a 100644
--- a/boost/hana/zip_with.hpp
+++ b/boost/hana/zip_with.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 
 
-BOOST_HANA_NAMESPACE_BEGIN
+namespace boost { namespace hana {
     //! @cond
     template <typename F, typename Xs, typename ...Ys>
     constexpr auto zip_with_t::operator()(F&& f, Xs&& xs, Ys&& ...ys) const {
@@ -65,6 +65,6 @@ BOOST_HANA_NAMESPACE_BEGIN
                               static_cast<X&&>(x), static_cast<Xs&&>(xs)...);
         }
     };
-BOOST_HANA_NAMESPACE_END
+}} // end namespace boost::hana
 
 #endif // !BOOST_HANA_ZIP_WITH_HPP
diff --git a/boost/pfr.hpp b/boost/pfr.hpp
index 3eaf421bc7e4e282d36d364b7e59b9a5e3e2d068..32ff067790363d59f6013aa86b10a1b6dfe408c7 100644
--- a/boost/pfr.hpp
+++ b/boost/pfr.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/core.hpp b/boost/pfr/core.hpp
index 6bbb4c65b880bf4c9aa1cb162000af841c5d443f..08837e62e13b5793a6dac34f3b8a69a923f02c92 100644
--- a/boost/pfr/core.hpp
+++ b/boost/pfr/core.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/cast_to_layout_compatible.hpp b/boost/pfr/detail/cast_to_layout_compatible.hpp
index d7106c62e4ba256a665105368959a0cb31fbec75..2dd0b5265ed6033c9e664e316703f327ec3c1334 100644
--- a/boost/pfr/detail/cast_to_layout_compatible.hpp
+++ b/boost/pfr/detail/cast_to_layout_compatible.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/config.hpp b/boost/pfr/detail/config.hpp
index e8ffb0ec3cee2780eefa553860d22182e88997ec..8a1ac7dcc1e30072ebfe1f50e4c5c056050112b5 100644
--- a/boost/pfr/detail/config.hpp
+++ b/boost/pfr/detail/config.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
@@ -45,15 +45,18 @@
 #           define BOOST_PFR_USE_CPP17 1
 #       else
 #           define BOOST_PFR_USE_CPP17 0
-#           if !BOOST_PFR_USE_LOOPHOLE
-#               error Boost.PFR requires /std:c++latest or /std:c++17 flags on your compiler.
-#           endif
 #       endif
 #   else
 #       define BOOST_PFR_USE_CPP17 0
 #   endif
 #endif
 
+#if (!BOOST_PFR_USE_CPP17 && !BOOST_PFR_USE_LOOPHOLE)
+#   if (defined(_MSC_VER) && _MSC_VER < 1916) ///< in Visual Studio 2017 v15.9 PFR library with classic engine normally works
+#      error Boost.PFR requires /std:c++latest or /std:c++17 flags on your compiler.
+#   endif
+#endif
+
 #ifndef BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE
 // Assume that libstdc++ since GCC-7.3 does not have linear instantiation depth in std::make_integral_sequence
 #   if defined( __GLIBCXX__) && __GLIBCXX__ >= 20180101
@@ -66,6 +69,14 @@
 #   endif
 #endif
 
+#ifndef BOOST_PFR_HAS_GUARANTEED_COPY_ELISION
+#   if  defined(__cpp_guaranteed_copy_elision) && (!defined(_MSC_VER) || _MSC_VER > 1928)
+#       define BOOST_PFR_HAS_GUARANTEED_COPY_ELISION 1
+#   else
+#       define BOOST_PFR_HAS_GUARANTEED_COPY_ELISION 0
+#   endif
+#endif
+
 #if defined(__has_cpp_attribute)
 #   if __has_cpp_attribute(maybe_unused)
 #       define BOOST_PFR_MAYBE_UNUSED [[maybe_unused]]
diff --git a/boost/pfr/detail/core.hpp b/boost/pfr/detail/core.hpp
index 88efa0d98d66477781747e840c63f7b7f5f542bf..aa67258426782519d9bcee6dd9f953cc4feea479 100644
--- a/boost/pfr/detail/core.hpp
+++ b/boost/pfr/detail/core.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/core14_classic.hpp b/boost/pfr/detail/core14_classic.hpp
index 610dbd3c8f8f9e5846eb69241b8d430c5559cb51..a27d081258e2ce9b38d367e7e3c5af0f58c058f6 100644
--- a/boost/pfr/detail/core14_classic.hpp
+++ b/boost/pfr/detail/core14_classic.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
@@ -549,6 +549,11 @@ constexpr bool is_flat_refelectable(std::index_sequence<I...>) noexcept {
     return true;
 }
 
+template<class T>
+constexpr bool is_flat_refelectable(std::index_sequence<>) noexcept {
+    return true; ///< all empty structs always flat refelectable
+}
+
 template <class T>
 auto tie_as_flat_tuple(T& lvalue) noexcept {
     static_assert(
diff --git a/boost/pfr/detail/core14_loophole.hpp b/boost/pfr/detail/core14_loophole.hpp
index 88c4c2aaf92e6d49eac5b23eb9674104e4eb8225..204a3c4652f0db09c71d6f7ceeb929082d3adb10 100644
--- a/boost/pfr/detail/core14_loophole.hpp
+++ b/boost/pfr/detail/core14_loophole.hpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2017-2018 Alexandr Poltavsky, Antony Polukhin.
-// Copyright (c) 2019-2021 Antony Polukhin.
+// Copyright (c) 2019-2022 Antony Polukhin.
 //
 // 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)
diff --git a/boost/pfr/detail/core17.hpp b/boost/pfr/detail/core17.hpp
index 20a2821ce4515ed651b1e00087876ce527a88ce5..1152806eb0830b716d1eee6e6cf7e8bebe6b1f47 100644
--- a/boost/pfr/detail/core17.hpp
+++ b/boost/pfr/detail/core17.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/core17_generated.hpp b/boost/pfr/detail/core17_generated.hpp
index d3098cd3ff529f0e37c9c08e2edde268e954e3f6..d158c5a8b97018259adfb58c759ed2a02f863fd4 100644
--- a/boost/pfr/detail/core17_generated.hpp
+++ b/boost/pfr/detail/core17_generated.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/detectors.hpp b/boost/pfr/detail/detectors.hpp
index e18be7dcdfe797266da55e0e10538d87cba18cf8..a76346cefb76f698e4c48632d1fad867e059dd3d 100644
--- a/boost/pfr/detail/detectors.hpp
+++ b/boost/pfr/detail/detectors.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/fields_count.hpp b/boost/pfr/detail/fields_count.hpp
index 5c2bea3aafaa0f2fd1ee46b0d156779d4cb336e5..acdfbbe70de69424a1acaa19e3f3024a2020451f 100644
--- a/boost/pfr/detail/fields_count.hpp
+++ b/boost/pfr/detail/fields_count.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
@@ -31,19 +31,19 @@ struct ubiq_lref_constructor {
     std::size_t ignore;
     template <class Type> constexpr operator Type&() const && noexcept {  // tweak for template_unconstrained.cpp like cases
         return detail::unsafe_declval<Type&>();
-    };
+    }
 
     template <class Type> constexpr operator Type&() const & noexcept {  // tweak for optional_chrono.cpp like cases
         return detail::unsafe_declval<Type&>();
-    };
+    }
 };
 
 ///////////////////// Structure that can be converted to rvalue reference to anything
 struct ubiq_rref_constructor {
     std::size_t ignore;
-    template <class Type> /*constexpr*/ operator Type&&() const && noexcept {  // Allows initialization of rvalue reference fields and move-only types
-        return detail::unsafe_declval<Type&&>();
-    };
+    template <class Type> /*constexpr*/ operator Type() const && noexcept {  // Allows initialization of rvalue reference fields and move-only types
+        return detail::unsafe_declval<Type>();
+    }
 };
 
 
@@ -93,6 +93,60 @@ struct is_aggregate_initializable_n {
 
 #endif // #ifndef __cpp_lib_is_aggregate
 
+///////////////////// Detect aggregates with inheritance
+template <class Derived, class U>
+constexpr bool static_assert_non_inherited() noexcept {
+    static_assert(
+            !std::is_base_of<U, Derived>::value,
+            "====================> Boost.PFR: Boost.PFR: Inherited types are not supported."
+    );
+    return true;
+}
+
+template <class Derived>
+struct ubiq_lref_base_asserting {
+    template <class Type> constexpr operator Type&() const &&  // tweak for template_unconstrained.cpp like cases
+        noexcept(detail::static_assert_non_inherited<Derived, Type>())  // force the computation of assert function
+    {
+        return detail::unsafe_declval<Type&>();
+    }
+
+    template <class Type> constexpr operator Type&() const &  // tweak for optional_chrono.cpp like cases
+        noexcept(detail::static_assert_non_inherited<Derived, Type>())  // force the computation of assert function
+    {
+        return detail::unsafe_declval<Type&>();
+    }
+};
+
+template <class Derived>
+struct ubiq_rref_base_asserting {
+    template <class Type> /*constexpr*/ operator Type() const &&  // Allows initialization of rvalue reference fields and move-only types
+        noexcept(detail::static_assert_non_inherited<Derived, Type>())  // force the computation of assert function
+    {
+        return detail::unsafe_declval<Type>();
+    }
+};
+
+template <class T, std::size_t I0, std::size_t... I, class /*Enable*/ = typename std::enable_if<std::is_copy_constructible<T>::value>::type>
+constexpr auto assert_first_not_base(std::index_sequence<I0, I...>) noexcept
+    -> typename std::add_pointer<decltype(T{ ubiq_lref_base_asserting<T>{}, ubiq_lref_constructor{I}... })>::type
+{
+    return nullptr;
+}
+
+template <class T, std::size_t I0, std::size_t... I, class /*Enable*/ = typename std::enable_if<!std::is_copy_constructible<T>::value>::type>
+constexpr auto assert_first_not_base(std::index_sequence<I0, I...>) noexcept
+    -> typename std::add_pointer<decltype(T{ ubiq_rref_base_asserting<T>{}, ubiq_rref_constructor{I}... })>::type
+{
+    return nullptr;
+}
+
+template <class T>
+constexpr void* assert_first_not_base(std::index_sequence<>) noexcept
+{
+    return nullptr;
+}
+
 ///////////////////// Helper for SFINAE on fields count
 template <class T, std::size_t... I, class /*Enable*/ = typename std::enable_if<std::is_copy_constructible<T>::value>::type>
 constexpr auto enable_if_constructible_helper(std::index_sequence<I...>) noexcept
@@ -210,6 +264,7 @@ constexpr std::size_t fields_count() noexcept {
         "====================> Boost.PFR: Attempt to get fields count on a reference. This is not allowed because that could hide an issue and different library users expect different behavior in that case."
     );
 
+#if !BOOST_PFR_HAS_GUARANTEED_COPY_ELISION
     static_assert(
         std::is_copy_constructible<std::remove_all_extents_t<type>>::value || (
             std::is_move_constructible<std::remove_all_extents_t<type>>::value
@@ -217,6 +272,7 @@ constexpr std::size_t fields_count() noexcept {
         ),
         "====================> Boost.PFR: Type and each field in the type must be copy constructible (or move constructible and move assignable)."
     );
+#endif  // #if !BOOST_PFR_HAS_GUARANTEED_COPY_ELISION
 
     static_assert(
         !std::is_polymorphic<type>::value,
@@ -239,9 +295,17 @@ constexpr std::size_t fields_count() noexcept {
 //    );
 //#endif
 
+#if defined(_MSC_VER) && (_MSC_VER <= 1920)
+    // Workaround for msvc compilers. Versions <= 1920 have a limit of max 1024 elements in template parameter pack
+    constexpr std::size_t max_fields_count = (sizeof(type) * CHAR_BIT >= 1024 ? 1024 : sizeof(type) * CHAR_BIT);
+#else
     constexpr std::size_t max_fields_count = (sizeof(type) * CHAR_BIT); // We multiply by CHAR_BIT because the type may have bitfields in T
+#endif
+
     constexpr std::size_t result = detail::detect_fields_count_dispatch<type>(size_t_<max_fields_count>{}, 1L, 1L);
 
+    detail::assert_first_not_base<type>(detail::make_index_sequence<result>{});
+
 #ifndef __cpp_lib_is_aggregate
     static_assert(
         is_aggregate_initializable_n<type, result>::value,
diff --git a/boost/pfr/detail/for_each_field_impl.hpp b/boost/pfr/detail/for_each_field_impl.hpp
index 3584f452ea65d4420d3aa4014fa33e69e004a1fe..e69f26dc23eba4b32896da79203fc799cd6b7cea 100644
--- a/boost/pfr/detail/for_each_field_impl.hpp
+++ b/boost/pfr/detail/for_each_field_impl.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
@@ -31,7 +31,7 @@ void for_each_field_impl_apply(T&& v, F&& f, I /*i*/, int) {
 
 template <class T, class F, std::size_t... I>
 void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::false_type /*move_values*/) {
-     const int v[] = {(
+     const int v[] = {0, (
          detail::for_each_field_impl_apply(sequence_tuple::get<I>(t), std::forward<F>(f), size_t_<I>{}, 1L),
          0
      )...};
@@ -41,7 +41,7 @@ void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::false_type
 
 template <class T, class F, std::size_t... I>
 void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::true_type /*move_values*/) {
-     const int v[] = {(
+     const int v[] = {0, (
          detail::for_each_field_impl_apply(sequence_tuple::get<I>(std::move(t)), std::forward<F>(f), size_t_<I>{}, 1L),
          0
      )...};
diff --git a/boost/pfr/detail/functional.hpp b/boost/pfr/detail/functional.hpp
index eb2401eed500656087479c3134ea6900d71de04d..363f52b95fed0905817bd5ddea1c662fc29e109a 100644
--- a/boost/pfr/detail/functional.hpp
+++ b/boost/pfr/detail/functional.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
@@ -10,6 +10,7 @@
 #include <boost/pfr/detail/config.hpp>
 
 #include <functional>
+#include <cstdint>
 
 #include <boost/pfr/detail/sequence_tuple.hpp>
 
@@ -116,11 +117,57 @@ namespace boost { namespace pfr { namespace detail {
         }
     };
 
+    // Hash combine functions copied from Boost.ContainerHash
+    // https://github.com/boostorg/container_hash/blob/171c012d4723c5e93cc7cffe42919afdf8b27dfa/include/boost/container_hash/hash.hpp#L311
+    // that is based on Peter Dimov's proposal
+    // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
+    // issue 6.18.
+    //
+    // This also contains public domain code from MurmurHash. From the
+    // MurmurHash header:
+    //
+    // MurmurHash3 was written by Austin Appleby, and is placed in the public
+    // domain. The author hereby disclaims copyright to this source code.
     template <typename SizeT>
     constexpr void hash_combine(SizeT& seed, SizeT value) noexcept {
         seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
     }
 
+    constexpr auto rotl(std::uint32_t x, std::uint32_t r) noexcept {
+        return (x << r) | (x >> (32 - r));
+    }
+
+    constexpr void hash_combine(std::uint32_t& h1, std::uint32_t k1) noexcept {
+          const std::uint32_t c1 = 0xcc9e2d51;
+          const std::uint32_t c2 = 0x1b873593;
+
+          k1 *= c1;
+          k1 = detail::rotl(k1,15);
+          k1 *= c2;
+
+          h1 ^= k1;
+          h1 = detail::rotl(h1,13);
+          h1 = h1*5+0xe6546b64;
+    }
+
+#if defined(INT64_MIN) && defined(UINT64_MAX)
+    constexpr void hash_combine(std::uint64_t& h, std::uint64_t k) noexcept {
+        const std::uint64_t m = 0xc6a4a7935bd1e995ULL;
+        const int r = 47;
+
+        k *= m;
+        k ^= k >> r;
+        k *= m;
+
+        h ^= k;
+        h *= m;
+
+        // Completely arbitrary number, to prevent 0's
+        // from hashing to 0.
+        h += 0xe6546b64;
+    }
+#endif
+
     template <typename T>
     auto compute_hash(const T& value, long /*priority*/)
         -> decltype(std::hash<T>()(value))
@@ -171,12 +218,13 @@ namespace boost { namespace pfr { namespace detail {
         ::boost::pfr::detail::for_each_field_dispatcher(
             x,
             [&result, &y](const auto& lhs) {
+                constexpr std::size_t fields_count_rhs_ = detail::fields_count<std::remove_reference_t<U>>();
                 ::boost::pfr::detail::for_each_field_dispatcher(
                     y,
                     [&result, &lhs](const auto& rhs) {
                         result = visitor_t::cmp(lhs, rhs);
                     },
-                    detail::make_index_sequence<fields_count_rhs>{}
+                    detail::make_index_sequence<fields_count_rhs_>{}
                 );
             },
             detail::make_index_sequence<fields_count_lhs>{}
diff --git a/boost/pfr/detail/io.hpp b/boost/pfr/detail/io.hpp
index 441fb2f2ed0932af27bb5475ed74a55324b504ba..15d2706c5d56e7b801bd64670744a17e5426166a 100644
--- a/boost/pfr/detail/io.hpp
+++ b/boost/pfr/detail/io.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/make_flat_tuple_of_references.hpp b/boost/pfr/detail/make_flat_tuple_of_references.hpp
index 8606f09da021494575534ac7a39c439b979a2feb..82bce1ab7201c06fe4f02f6f9d0c6fb681de0a44 100644
--- a/boost/pfr/detail/make_flat_tuple_of_references.hpp
+++ b/boost/pfr/detail/make_flat_tuple_of_references.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/make_integer_sequence.hpp b/boost/pfr/detail/make_integer_sequence.hpp
index 74f3e6572d961313d6d5a1dbb31421c2ebbb3af9..f143a501cec1a8539da3e0af05b508b5738e72e3 100644
--- a/boost/pfr/detail/make_integer_sequence.hpp
+++ b/boost/pfr/detail/make_integer_sequence.hpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2018 Sergei Fedorov
-// Copyright (c) 2019-2021 Antony Polukhin
+// Copyright (c) 2019-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/offset_based_getter.hpp b/boost/pfr/detail/offset_based_getter.hpp
index 4265007154d72745fa4eaca9ef9bae28331288b2..4739a04435d28490d098a34db7cfe057f667eacf 100644
--- a/boost/pfr/detail/offset_based_getter.hpp
+++ b/boost/pfr/detail/offset_based_getter.hpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2017-2018 Chris Beck
-// Copyright (c) 2019-2021 Antony Polukhin
+// Copyright (c) 2019-2022 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -12,6 +12,7 @@
 
 #include <type_traits>
 #include <utility>
+#include <memory>  // std::addressof
 #include <boost/pfr/detail/sequence_tuple.hpp>
 #include <boost/pfr/detail/rvalue_t.hpp>
 #include <boost/pfr/detail/size_t_.hpp>
diff --git a/boost/pfr/detail/rvalue_t.hpp b/boost/pfr/detail/rvalue_t.hpp
index e41bea4e1b182003f617d45341592998124e8895..e2ff13e767a50dfc1ef4b1391ce94ddbae1853f7 100644
--- a/boost/pfr/detail/rvalue_t.hpp
+++ b/boost/pfr/detail/rvalue_t.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/sequence_tuple.hpp b/boost/pfr/detail/sequence_tuple.hpp
index a3df105c330038f8f5f630f07f5b792e78c02329..ead19e95e50663102b5f7485d902f8d5242c4d63 100644
--- a/boost/pfr/detail/sequence_tuple.hpp
+++ b/boost/pfr/detail/sequence_tuple.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/size_array.hpp b/boost/pfr/detail/size_array.hpp
index d94c7d5a2ad1541fb8e4f00f37b6ea274987da41..86f74e687a78698b3898da699540497c6f7c33f5 100644
--- a/boost/pfr/detail/size_array.hpp
+++ b/boost/pfr/detail/size_array.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/size_t_.hpp b/boost/pfr/detail/size_t_.hpp
index c1ae6a8fe12be33eedddd2ed348888b68616208f..11bf18ab16e28cc15a59368b33e595848ba2dfaf 100644
--- a/boost/pfr/detail/size_t_.hpp
+++ b/boost/pfr/detail/size_t_.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/stdtuple.hpp b/boost/pfr/detail/stdtuple.hpp
index f3213bfa09b14289a6524b5e0bf09b690fabbac4..25d6a71960015af85841a9a4fd0c9e86922dbce7 100644
--- a/boost/pfr/detail/stdtuple.hpp
+++ b/boost/pfr/detail/stdtuple.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/detail/tie_from_structure_tuple.hpp b/boost/pfr/detail/tie_from_structure_tuple.hpp
index a01fdd55110dcf943cb0fc7ed240ebfcc8e56e0c..451d80ed0e7179f3057524f8bf8d380913ed7532 100644
--- a/boost/pfr/detail/tie_from_structure_tuple.hpp
+++ b/boost/pfr/detail/tie_from_structure_tuple.hpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2018 Adam Butcher, Antony Polukhin
-// Copyright (c) 2019-2021 Antony Polukhin
+// Copyright (c) 2019-2022 Antony Polukhin
 //
 // 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)
@@ -39,6 +39,6 @@ struct tie_from_structure_tuple : std::tuple<Elements&...> {
     }
 };
 
-}}} // boost::pfr::detail
+}}} // namespace boost::pfr::detail
 
 #endif // BOOST_PFR_DETAIL_TIE_FROM_STRUCTURE_TUPLE_HPP
diff --git a/boost/pfr/detail/unsafe_declval.hpp b/boost/pfr/detail/unsafe_declval.hpp
index e8e3af69dbfc13c022b23970f07b8b3f68e6bc6e..62404c50450d5e21e5b918953acf200629762099 100644
--- a/boost/pfr/detail/unsafe_declval.hpp
+++ b/boost/pfr/detail/unsafe_declval.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 Antony Polukhin.
+// Copyright (c) 2019-2022 Antony Polukhin.
 //
 // 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)
diff --git a/boost/pfr/functions_for.hpp b/boost/pfr/functions_for.hpp
index b736c0b4941be167f52584b8357e12a30930a27b..a2935353a79633032c4c1dc8bf9e84ef1ce3c62d 100644
--- a/boost/pfr/functions_for.hpp
+++ b/boost/pfr/functions_for.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/functors.hpp b/boost/pfr/functors.hpp
index 4a63c26e4501875f82f8153999a4d03a9040440a..21b78da624a2a213c3171507a26a84d06ab2b4fb 100644
--- a/boost/pfr/functors.hpp
+++ b/boost/pfr/functors.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/io.hpp b/boost/pfr/io.hpp
index c09011e2f9442b495d8b73edf7d793f100664bf0..ef2ec0915f486a2ac54bc09008c62e21d366f447 100644
--- a/boost/pfr/io.hpp
+++ b/boost/pfr/io.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/io_fields.hpp b/boost/pfr/io_fields.hpp
index 0363612413c46e99151fe61e7957926374b003ae..6feeae67d97f466afc0dfe2412b1a6c7cbf838a6 100644
--- a/boost/pfr/io_fields.hpp
+++ b/boost/pfr/io_fields.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
@@ -120,13 +120,13 @@ std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& i
 
 template <class Char, class Traits, class T>
 std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, io_fields_impl<const T&>&& ) {
-    static_assert(sizeof(T) && false, "====================> Boost.PFR: Atetmpt to use istream operator on a boost::pfr::io_fields wrapped type T with const qualifier.");
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Attempt to use istream operator on a boost::pfr::io_fields wrapped type T with const qualifier.");
     return in;
 }
 
 template <class Char, class Traits, class T>
 std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, io_fields_impl<T>&& ) {
-    static_assert(sizeof(T) && false, "====================> Boost.PFR: Atetmpt to use istream operator on a boost::pfr::io_fields wrapped temporary of type T.");
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Attempt to use istream operator on a boost::pfr::io_fields wrapped temporary of type T.");
     return in;
 }
 
diff --git a/boost/pfr/ops.hpp b/boost/pfr/ops.hpp
index 8b36bc6f5f6da219fee0db0c9dd2d4e7abb033dc..9474e20b904ba4e6ce5d39e7beecca57ea6202c7 100644
--- a/boost/pfr/ops.hpp
+++ b/boost/pfr/ops.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/ops_fields.hpp b/boost/pfr/ops_fields.hpp
index ee71900f61168437598e33b1eda105924c4b5a83..b4d1e6f7c21ddb95e91d70229d711cdafba4f387 100644
--- a/boost/pfr/ops_fields.hpp
+++ b/boost/pfr/ops_fields.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boost/pfr/tuple_size.hpp b/boost/pfr/tuple_size.hpp
index 8c25ef991d87d58cf0202dec5a79e96e68922c08..3958e50290c598041c9574c150856a9fbdb13c5a 100644
--- a/boost/pfr/tuple_size.hpp
+++ b/boost/pfr/tuple_size.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2022 Antony Polukhin
 //
 // 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)
diff --git a/boostcpp.jam b/boostcpp.jam
index 299401778dcfbe7a5bcace1ead26292be8b3fdea..082536e2a54d5ef92ccbc41619b086bbe321c425 100644
--- a/boostcpp.jam
+++ b/boostcpp.jam
@@ -278,9 +278,24 @@ rule declare_install_and_stage_proper_targets ( libraries * )
 #
 ################################################################################
 
+rule emit-shared-static-warning ( )
+{
+    if ! $(.shared-static-warning-emitted)
+    {
+        ECHO "" ;
+        ECHO "warning: The configuration link=shared, runtime-link=static is disabled" ;
+        ECHO "warning: by default as being too dangerous to use, and will not be built." ;
+        ECHO "warning: To enable it, use --allow-shared-static." ;
+        ECHO "" ;
+
+        .shared-static-warning-emitted = 1 ;
+    }
+}
+
 class top-level-target : alias-target-class
 {
     import modules ;
+    import boostcpp ;
 
     rule __init__ ( name : project : sources * : requirements *
         : default-build * : usage-requirements * )
@@ -374,15 +389,22 @@ class top-level-target : alias-target-class
                 : $(build-type-set) ] ;
 
             # Filter inappopriate combinations.
+
             local filtered ;
+            local skipped ;
+
+            local argv = [ modules.peek : ARGV ] ;
+
             for local p in $(expanded)
             {
                 # See comment in handle-static-runtime regarding this logic.
                 if [ $(p).get <link> ] = shared
                     && [ $(p).get <runtime-link> ] = static
                     && [ $(p).get <toolset> ] != cw
+                    && ! --allow-shared-static in $(argv)
                 {
                     # Skip this.
+                    skipped += $(p) ;
                 }
                 else
                 {
@@ -390,6 +412,11 @@ class top-level-target : alias-target-class
                 }
             }
 
+            if $(expanded) = $(skipped)
+            {
+                boostcpp.emit-shared-static-warning ;
+            }
+
             return [ build-multiple $(filtered) ] ;
         }
     }
diff --git a/bootstrap.bat b/bootstrap.bat
index 03c98ffcc321b2b10261ad1d44aaa606d361c637..876a7638f10f3c5d4f60c7ed7e4f9fdf1763a71c 100644
--- a/bootstrap.bat
+++ b/bootstrap.bat
@@ -44,6 +44,7 @@ IF "%1"=="vc12" SET TOOLSET=msvc : 12.0
 IF "%1"=="vc14" SET TOOLSET=msvc : 14.0
 IF "%1"=="vc141" SET TOOLSET=msvc : 14.1
 IF "%1"=="vc142" SET TOOLSET=msvc : 14.2
+IF "%1"=="vc143" SET TOOLSET=msvc : 14.3
 
 ECHO.
 ECHO Generating Boost.Build configuration in project-config.jam for %TOOLSET%...
diff --git a/libs/maintainers.txt b/libs/maintainers.txt
index d048f9b3ff274e89c9ecfe57b3306576fc0d6532..ab9934674f3306628adf3efdcd71f699eb30b702 100644
--- a/libs/maintainers.txt
+++ b/libs/maintainers.txt
@@ -31,6 +31,7 @@ compute               Kyle Lutz <kyle.r.lutz -at- gmail.com>
 concept_check         Jeremy Siek <jeremy.siek -at- gmail.com>
 config                John Maddock <john -at- johnmaddock.co.uk>
 container             Ion Gaztanaga <igaztanaga -at- gmail.com>
+container_hash        Daniel James <dnljms -at- gmail.com>
 context               Oliver Kowalke <oliver.kowalke -at- gmail.com>
 contract              Lorenzo Caminiti <lorcaminiti -at- gmail.com>
 conversion            Antony Polukhin <antoshkka -at- gmail.com>
@@ -40,6 +41,7 @@ coroutine             Oliver Kowalke <oliver.kowalke -at- gmail.com>
 coroutine2            Oliver Kowalke <oliver.kowalke -at- gmail.com>
 crc                   Daryle Walker <darylew -at- hotmail.com>
 date_time             Jeff Garland <jeff -at- crystalclearsoftware.com>, James E. King III <jking -at- apache.org>
+describe              Peter Dimov <pdimov -at- gmail.com>
 detail                Robert Ramey <ramey -at- rrsd.com>, Rene Rivera <grafikrobot -at- gmail.com>, Andrey Semashev <andrey.semashev -at- gmail.com>
 disjoint_sets         Jeremy Siek <jeremy.siek -at- gmail.com>
 dll                   Antony Polukhin <antoshkka -at- gmail.com>
@@ -79,6 +81,7 @@ iterator              David Abrahams <dave -at- boost-consulting.com>, Thomas Wi
 iterator_facade       Zach Laine <whatwasthataddress -at- gmail.com>
 json                  Vinnie Falco <vinnie.falco@gmail.com>
 lambda                Jaakko Jarvi <jarvi -at- cs.tamu.edu>
+lambda2               Peter Dimov <pdimov -at- gmail.com>
 leaf                  Emil Dotchevski
 lexical_cast          Antony Polukhin <antoshkka -at- gmail.com>
 local_function        Lorenzo Caminiti <lorcaminiti -at- gmail.com>
@@ -103,7 +106,7 @@ numeric/odeint        Karsten Ahnert <karsten.ahnert -at- gmx.de>, Mario Mulansk
 numeric/ublas         David Bellot <david.bellot -at- gmail.com>, Stefan Seefeld <stefan -at- seefeld.name>
 operators             Daniel Frey <d.frey -at- gmx.de>
 optional              Fernando Cacciola <fernando_cacciola -at- ciudad.com.ar>, Andrzej Krzemienski <akrzemi1 -at- gmail.com>
-outcome               Niall Douglas
+outcome               Niall Douglas <s -underscore- sourceforge -at- nedprod -dot- com>
 parameter             David Abrahams <dave -at- boost-consulting.com>, Daniel Wallin <daniel -at- boostpro.com>
 parameter_python      David Abrahams <dave -at- boost-consulting.com>, Daniel Wallin <daniel -at- boostpro.com>
 pfr                   Antony Polukhin <antoshkka -at- gmail.com>
@@ -116,6 +119,7 @@ preprocessor          Paul Mensonides <pmenso57 -at- comcast.net>, Edward Diener
 process               Klemens D. Morgenstern <klemens.morgenstern -at- gmx.net>
 program_options       Vladimir Prus <vladimir.prus -at- gmail.com>
 property_map          Douglas Gregor <dgregor -at- cs.indiana.edu>
+property_map_parallel Douglas Gregor <dgregor -at- cs.indiana.edu>
 property_tree         Richard Hodges <hodges.r@gmail.com>
 proto                 Eric Niebler <eric -at- boostpro.com>
 ptr_container         Thorsten Ottosen <nesotto -at- cs.auc.dk>
@@ -142,6 +146,7 @@ statechart            Andreas Huber <ahd6974-boostorg -at- yahoo.com>
 static_assert         John Maddock <john -at- johnmaddock.co.uk>
 static_string         Krystian Stasiowski <sdkrystian@gmail.com>, Vinnie Falco <vinnie.falco@gmail.com>
 stl_interfaces        Zach Laine <whatwasthataddress -at- gmail.com>
+system                Peter Dimov <pdimov -at- gmail.com>
 test                  Gennadiy Rozental <rogeeff -at- gmail.com>, Raffi Enficiaud <raffi.enficiaud -at- free.fr>
 thread                Vicente J. Botet Escriba <vicente.botet -at- wanadoo.fr>
 throw_exception       Emil Dotchevski <emil -at- revergestudios.com>, Peter Dimov <pdimov -at- gmail.com>