diff --git a/asio/src/doc/reference.qbk b/asio/src/doc/reference.qbk
index 7f2c3264..00eb3240 100644
--- a/asio/src/doc/reference.qbk
+++ b/asio/src/doc/reference.qbk
@@ -64,13 +64,138 @@
 
 
 
+[section:any_io_executor any_io_executor]
+
+[indexterm1 asio.indexterm.any_io_executor..any_io_executor] 
+Polymorphic executor type for use with I/O objects. 
+
+
+  typedef execution::any_executor<...> any_io_executor;
+
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__any_executor.any_executor [*any_executor]]]
+    [Default constructor. 
+     [hr]
+     Copy constructor. 
+     [hr]
+     Move constructor. 
+     [hr]
+     Construct to point to the same target as another any_executor. 
+     [hr]
+     Construct a polymorphic wrapper for the specified executor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.context [*context]]]
+    [Obtain the underlying execution context. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.execute [*execute]]]
+    [Execute the function on the target executor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.operator_bool [*operator bool]]]
+    [Determine whether the wrapper has a target executor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.operator_eq_ [*operator=]]]
+    [Assignment operator. 
+     [hr]
+     Move assignment operator. 
+     [hr]
+     Assignment operator to create a polymorphic wrapper for the specified executor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.prefer [*prefer]]]
+    [Obtain a polymorphic wrapper with the specified property. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.query [*query]]]
+    [Obtain the value associated with the specified property. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.require [*require]]]
+    [Obtain a polymorphic wrapper with the specified property. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.target [*target]]]
+    [Get a pointer to the target executor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.target_type [*target_type]]]
+    [Get the type of the target executor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor._any_executor [*~any_executor]]]
+    [Destructor. ]
+  ]
+  
+]
+
+[heading Related Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__any_executor.operator_not__eq_ [*operator!=]]]
+    [Inequality operator. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.operator_eq__eq_ [*operator==]]]
+    [Equality operator. ]
+  ]
+  
+]
+
+
+The `any_io_executor` type is a polymorphic executor that supports the set of properties required by I/O objects. It is defined as the [link asio.reference.execution__any_executor `execution::any_executor`] class template parameterised as follows: 
+
+   execution::any_executor<
+     execution::context_as_t<execution_context&>,
+     execution::blocking_t::never_t,
+     execution::prefer_only<execution::blocking_t::possibly_t>,
+     execution::prefer_only<execution::outstanding_work_t::tracked_t>,
+     execution::prefer_only<execution::outstanding_work_t::untracked_t>,
+     execution::prefer_only<execution::relationship_t::fork_t>,
+     execution::prefer_only<execution::relationship_t::continuation_t>
+   > 
+
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/any_io_executor.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+
 [section:asio_handler_allocate asio_handler_allocate]
 
 [indexterm1 asio.indexterm.asio_handler_allocate..asio_handler_allocate] 
-Default allocation function for handlers. 
+(Deprecated: Use the [link asio.reference.associated_allocator `associated_allocator`] trait.) Default allocation function for handlers. 
 
 
-  void * asio_handler_allocate(
+  asio_handler_allocate_is_deprecated asio_handler_allocate(
       std::size_t size,
       ... );
 
@@ -126,7 +251,7 @@ All temporary objects associated with a handler will be deallocated before the u
 Default deallocation function for handlers. 
 
 
-  void asio_handler_deallocate(
+  asio_handler_deallocate_is_deprecated asio_handler_deallocate(
       void * pointer,
       std::size_t size,
       ... );
@@ -152,14 +277,14 @@ The default implementation of these allocation hooks uses `operator new` and `op
 [section:asio_handler_invoke asio_handler_invoke]
 
 [indexterm1 asio.indexterm.asio_handler_invoke..asio_handler_invoke] 
-Default invoke function for handlers. 
+(Deprecated: Use the [link asio.reference.associated_executor `associated_executor`] trait.) Default invoke function for handlers. 
 
 
 Default handler invocation hook used for non-const function objects. 
 
   template<
       typename Function>
-  void ``[link asio.reference.asio_handler_invoke.overload1 asio_handler_invoke]``(
+  asio_handler_invoke_is_deprecated ``[link asio.reference.asio_handler_invoke.overload1 asio_handler_invoke]``(
       Function & function,
       ... );
   ``  [''''&raquo;''' [link asio.reference.asio_handler_invoke.overload1 more...]]``
@@ -168,7 +293,7 @@ Default handler invocation hook used for const function objects.
 
   template<
       typename Function>
-  void ``[link asio.reference.asio_handler_invoke.overload2 asio_handler_invoke]``(
+  asio_handler_invoke_is_deprecated ``[link asio.reference.asio_handler_invoke.overload2 asio_handler_invoke]``(
       const Function & function,
       ... );
   ``  [''''&raquo;''' [link asio.reference.asio_handler_invoke.overload2 more...]]``
@@ -219,7 +344,7 @@ Default handler invocation hook used for non-const function objects.
 
   template<
       typename Function>
-  void asio_handler_invoke(
+  asio_handler_invoke_is_deprecated asio_handler_invoke(
       Function & function,
       ... );
 
@@ -237,7 +362,7 @@ Default handler invocation hook used for const function objects.
 
   template<
       typename Function>
-  void asio_handler_invoke(
+  asio_handler_invoke_is_deprecated asio_handler_invoke(
       const Function & function,
       ... );
 
@@ -5439,7 +5564,7 @@ The return type of a coroutine or asynchronous operation.
 
   template<
       typename T,
-      typename ``[link asio.reference.Executor1 Executor]`` = executor>
+      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
   class awaitable
 
 
@@ -12431,7 +12556,7 @@ Provides waitable timer functionality.
   template<
       typename Time,
       typename ``[link asio.reference.TimeTraits TimeTraits]`` = asio::time_traits<Time>,
-      typename ``[link asio.reference.Executor1 Executor]`` = executor>
+      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
   class basic_deadline_timer
 
 
@@ -14175,63 +14300,6 @@ The type of the executor associated with the object.
   typedef asio::io_context::executor_type executor_type;
 
 
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context__executor_type.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__executor_type.defer [*defer]]]
-    [Request the io_context to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__executor_type.dispatch [*dispatch]]]
-    [Request the io_context to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__executor_type.on_work_finished [*on_work_finished]]]
-    [Inform the io_context that some work is no longer outstanding. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__executor_type.on_work_started [*on_work_started]]]
-    [Inform the io_context that it has some outstanding work to do. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__executor_type.post [*post]]]
-    [Request the io_context to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__executor_type.running_in_this_thread [*running_in_this_thread]]]
-    [Determine whether the io_context is running in the current thread. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context__executor_type.operator_not__eq_ [*operator!=]]]
-    [Compare two executors for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__executor_type.operator_eq__eq_ [*operator==]]]
-    [Compare two executors for equality. ]
-  ]
-  
-]
-
 
 [heading Requirements]
 
@@ -27194,7 +27262,7 @@ Provides serial port functionality.
 
 
   template<
-      typename ``[link asio.reference.Executor1 Executor]`` = executor>
+      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
   class basic_serial_port :
     public serial_port_base
 
@@ -29243,7 +29311,7 @@ Provides signal functionality.
 
 
   template<
-      typename ``[link asio.reference.Executor1 Executor]`` = executor>
+      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
   class basic_signal_set
 
 
@@ -50486,6 +50554,707 @@ Get the size of the input sequence.
 
 
 
+[endsect]
+
+[section:basic_system_executor basic_system_executor]
+
+
+An executor that uses arbitrary threads. 
+
+
+  template<
+      typename Blocking,
+      typename Relationship,
+      typename Allocator>
+  class basic_system_executor
+
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.basic_system_executor.basic_system_executor [*basic_system_executor]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.context [*context]]]
+    [Obtain the underlying execution context. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.defer [*defer]]]
+    [Request the system executor to invoke the given function object. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.dispatch [*dispatch]]]
+    [Request the system executor to invoke the given function object. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.execute [*execute]]]
+    [Oneway execution function. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.on_work_finished [*on_work_finished]]]
+    [Inform the executor that some work is no longer outstanding. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.on_work_started [*on_work_started]]]
+    [Inform the executor that it has some outstanding work to do. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.post [*post]]]
+    [Request the system executor to invoke the given function object. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.query [*query]]]
+    [Query the current value of the allocator property. 
+     [hr]
+     Query the occupancy (recommended number of work items) for the system context. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.query__static [*query]]]
+    [Query the current value of the mapping property. 
+     [hr]
+     Query the current value of the context property. 
+     [hr]
+     Query the current value of the blocking property. 
+     [hr]
+     Query the current value of the relationship property. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.require [*require]]]
+    [Obtain an executor with the blocking.possibly property. 
+     [hr]
+     Obtain an executor with the blocking.always property. 
+     [hr]
+     Obtain an executor with the blocking.never property. 
+     [hr]
+     Obtain an executor with the relationship.continuation property. 
+     [hr]
+     Obtain an executor with the relationship.fork property. 
+     [hr]
+     Obtain an executor with the specified allocator property. 
+     [hr]
+     Obtain an executor with the default allocator property. ]
+  ]
+  
+]
+
+[heading Friends]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.basic_system_executor.operator_not__eq_ [*operator!=]]]
+    [Compare two executors for inequality. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.operator_eq__eq_ [*operator==]]]
+    [Compare two executors for equality. ]
+  ]
+  
+]
+
+The system executor represents an execution context where functions are permitted to run on arbitrary threads. When the blocking.never property is established, the system executor will schedule the function to run on an unspecified system thread pool. When either blocking.possibly or blocking.always is established, the executor invokes the function immediately. 
+
+[heading Requirements]
+
+['Header: ][^asio/system_executor.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[section:basic_system_executor basic_system_executor::basic_system_executor]
+
+[indexterm2 asio.indexterm.basic_system_executor.basic_system_executor..basic_system_executor..basic_system_executor] 
+Default constructor. 
+
+
+  basic_system_executor();
+
+
+
+[endsect]
+
+
+
+[section:context basic_system_executor::context]
+
+[indexterm2 asio.indexterm.basic_system_executor.context..context..basic_system_executor] 
+Obtain the underlying execution context. 
+
+
+  system_context & context() const;
+
+
+
+[endsect]
+
+
+
+[section:defer basic_system_executor::defer]
+
+[indexterm2 asio.indexterm.basic_system_executor.defer..defer..basic_system_executor] 
+Request the system executor to invoke the given function object. 
+
+
+  template<
+      typename Function,
+      typename OtherAllocator>
+  void defer(
+      Function && f,
+      const OtherAllocator & a) const;
+
+
+This function is used to ask the executor to execute the given function object. The function object will never be executed inside this function. Instead, it will be scheduled to run on an unspecified system thread pool.
+
+
+[heading Parameters]
+    
+
+[variablelist
+  
+[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be:
+``
+   void function(); 
+``
+]]
+
+[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
+
+]
+
+
+
+
+[endsect]
+
+
+
+[section:dispatch basic_system_executor::dispatch]
+
+[indexterm2 asio.indexterm.basic_system_executor.dispatch..dispatch..basic_system_executor] 
+Request the system executor to invoke the given function object. 
+
+
+  template<
+      typename Function,
+      typename OtherAllocator>
+  void dispatch(
+      Function && f,
+      const OtherAllocator & a) const;
+
+
+This function is used to ask the executor to execute the given function object. The function object will always be executed inside this function.
+
+
+[heading Parameters]
+    
+
+[variablelist
+  
+[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be:
+``
+   void function(); 
+``
+]]
+
+[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
+
+]
+
+
+
+
+[endsect]
+
+
+
+[section:execute basic_system_executor::execute]
+
+[indexterm2 asio.indexterm.basic_system_executor.execute..execute..basic_system_executor] 
+Oneway execution function. 
+
+
+  template<
+      typename Function>
+  void execute(
+      Function && f) const;
+
+
+
+[endsect]
+
+
+
+[section:on_work_finished basic_system_executor::on_work_finished]
+
+[indexterm2 asio.indexterm.basic_system_executor.on_work_finished..on_work_finished..basic_system_executor] 
+Inform the executor that some work is no longer outstanding. 
+
+
+  void on_work_finished() const;
+
+
+For the system executor, this is a no-op. 
+
+
+[endsect]
+
+
+
+[section:on_work_started basic_system_executor::on_work_started]
+
+[indexterm2 asio.indexterm.basic_system_executor.on_work_started..on_work_started..basic_system_executor] 
+Inform the executor that it has some outstanding work to do. 
+
+
+  void on_work_started() const;
+
+
+For the system executor, this is a no-op. 
+
+
+[endsect]
+
+
+
+[section:operator_not__eq_ basic_system_executor::operator!=]
+
+[indexterm2 asio.indexterm.basic_system_executor.operator_not__eq_..operator!=..basic_system_executor] 
+Compare two executors for inequality. 
+
+
+  friend bool operator!=(
+      const basic_system_executor & ,
+      const basic_system_executor & );
+
+
+Two executors are equal if they refer to the same underlying [link asio.reference.io_context `io_context`]. 
+
+[heading Requirements]
+
+['Header: ][^asio/system_executor.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+
+[section:operator_eq__eq_ basic_system_executor::operator==]
+
+[indexterm2 asio.indexterm.basic_system_executor.operator_eq__eq_..operator==..basic_system_executor] 
+Compare two executors for equality. 
+
+
+  friend bool operator==(
+      const basic_system_executor & ,
+      const basic_system_executor & );
+
+
+Two executors are equal if they refer to the same underlying [link asio.reference.io_context `io_context`]. 
+
+[heading Requirements]
+
+['Header: ][^asio/system_executor.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+
+[section:post basic_system_executor::post]
+
+[indexterm2 asio.indexterm.basic_system_executor.post..post..basic_system_executor] 
+Request the system executor to invoke the given function object. 
+
+
+  template<
+      typename Function,
+      typename OtherAllocator>
+  void post(
+      Function && f,
+      const OtherAllocator & a) const;
+
+
+This function is used to ask the executor to execute the given function object. The function object will never be executed inside this function. Instead, it will be scheduled to run on an unspecified system thread pool.
+
+
+[heading Parameters]
+    
+
+[variablelist
+  
+[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be:
+``
+   void function(); 
+``
+]]
+
+[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
+
+]
+
+
+
+
+[endsect]
+
+
+[section:query basic_system_executor::query]
+
+[indexterm2 asio.indexterm.basic_system_executor.query..query..basic_system_executor] 
+Query the current value of the `allocator` property. 
+
+
+  template<
+      typename OtherAllocator>
+  constexpr Allocator ``[link asio.reference.basic_system_executor.query.overload1 query]``(
+      execution::allocator_t< OtherAllocator > ) const;
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query.overload1 more...]]``
+
+  constexpr Allocator ``[link asio.reference.basic_system_executor.query.overload2 query]``(
+      execution::allocator_t< void > ) const;
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query.overload2 more...]]``
+
+
+Query the occupancy (recommended number of work items) for the system context. 
+
+
+  std::size_t ``[link asio.reference.basic_system_executor.query.overload3 query]``(
+      execution::occupancy_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query.overload3 more...]]``
+
+
+[section:overload1 basic_system_executor::query (1 of 3 overloads)]
+
+
+Query the current value of the `allocator` property. 
+
+
+  template<
+      typename OtherAllocator>
+  constexpr Allocator query(
+      execution::allocator_t< OtherAllocator > ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 basic_system_executor::query (2 of 3 overloads)]
+
+
+Query the current value of the `allocator` property. 
+
+
+  constexpr Allocator query(
+      execution::allocator_t< void > ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload3 basic_system_executor::query (3 of 3 overloads)]
+
+
+Query the occupancy (recommended number of work items) for the system context. 
+
+
+  std::size_t query(
+      execution::occupancy_t ) const;
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:query__static basic_system_executor::query]
+
+[indexterm2 asio.indexterm.basic_system_executor.query__static..query..basic_system_executor] 
+Query the current value of the `mapping` property. 
+
+
+  static constexpr execution::mapping_t ``[link asio.reference.basic_system_executor.query__static.overload1 query]``(
+      execution::mapping_t );
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query__static.overload1 more...]]``
+
+
+Query the current value of the `context` property. 
+
+
+  static system_context & ``[link asio.reference.basic_system_executor.query__static.overload2 query]``(
+      execution::context_t );
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query__static.overload2 more...]]``
+
+
+Query the current value of the `blocking` property. 
+
+
+  static constexpr execution::blocking_t ``[link asio.reference.basic_system_executor.query__static.overload3 query]``(
+      execution::blocking_t );
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query__static.overload3 more...]]``
+
+
+Query the current value of the `relationship` property. 
+
+
+  static constexpr execution::relationship_t ``[link asio.reference.basic_system_executor.query__static.overload4 query]``(
+      execution::relationship_t );
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query__static.overload4 more...]]``
+
+
+[section:overload1 basic_system_executor::query (1 of 4 overloads)]
+
+
+Query the current value of the `mapping` property. 
+
+
+  static constexpr execution::mapping_t query(
+      execution::mapping_t );
+
+
+
+[endsect]
+
+
+
+[section:overload2 basic_system_executor::query (2 of 4 overloads)]
+
+
+Query the current value of the `context` property. 
+
+
+  static system_context & query(
+      execution::context_t );
+
+
+
+[endsect]
+
+
+
+[section:overload3 basic_system_executor::query (3 of 4 overloads)]
+
+
+Query the current value of the `blocking` property. 
+
+
+  static constexpr execution::blocking_t query(
+      execution::blocking_t );
+
+
+
+[endsect]
+
+
+
+[section:overload4 basic_system_executor::query (4 of 4 overloads)]
+
+
+Query the current value of the `relationship` property. 
+
+
+  static constexpr execution::relationship_t query(
+      execution::relationship_t );
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:require basic_system_executor::require]
+
+[indexterm2 asio.indexterm.basic_system_executor.require..require..basic_system_executor] 
+Obtain an executor with the `blocking.possibly` property. 
+
+
+  basic_system_executor< execution::blocking_t::possibly_t, Relationship, Allocator > ``[link asio.reference.basic_system_executor.require.overload1 require]``(
+      execution::blocking_t::possibly_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload1 more...]]``
+
+
+Obtain an executor with the `blocking.always` property. 
+
+
+  basic_system_executor< execution::blocking_t::always_t, Relationship, Allocator > ``[link asio.reference.basic_system_executor.require.overload2 require]``(
+      execution::blocking_t::always_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload2 more...]]``
+
+
+Obtain an executor with the `blocking.never` property. 
+
+
+  basic_system_executor< execution::blocking_t::never_t, Relationship, Allocator > ``[link asio.reference.basic_system_executor.require.overload3 require]``(
+      execution::blocking_t::never_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload3 more...]]``
+
+
+Obtain an executor with the `relationship.continuation` property. 
+
+
+  basic_system_executor< Blocking, execution::relationship_t::continuation_t, Allocator > ``[link asio.reference.basic_system_executor.require.overload4 require]``(
+      execution::relationship_t::continuation_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload4 more...]]``
+
+
+Obtain an executor with the `relationship.fork` property. 
+
+
+  basic_system_executor< Blocking, execution::relationship_t::fork_t, Allocator > ``[link asio.reference.basic_system_executor.require.overload5 require]``(
+      execution::relationship_t::fork_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload5 more...]]``
+
+
+Obtain an executor with the specified `allocator` property. 
+
+
+  template<
+      typename OtherAllocator>
+  basic_system_executor< Blocking, Relationship, OtherAllocator > ``[link asio.reference.basic_system_executor.require.overload6 require]``(
+      execution::allocator_t< OtherAllocator > a) const;
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload6 more...]]``
+
+
+Obtain an executor with the default `allocator` property. 
+
+
+  basic_system_executor< Blocking, Relationship, std::allocator< void > > ``[link asio.reference.basic_system_executor.require.overload7 require]``(
+      execution::allocator_t< void > ) const;
+  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload7 more...]]``
+
+
+[section:overload1 basic_system_executor::require (1 of 7 overloads)]
+
+
+Obtain an executor with the `blocking.possibly` property. 
+
+
+  basic_system_executor< execution::blocking_t::possibly_t, Relationship, Allocator > require(
+      execution::blocking_t::possibly_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 basic_system_executor::require (2 of 7 overloads)]
+
+
+Obtain an executor with the `blocking.always` property. 
+
+
+  basic_system_executor< execution::blocking_t::always_t, Relationship, Allocator > require(
+      execution::blocking_t::always_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload3 basic_system_executor::require (3 of 7 overloads)]
+
+
+Obtain an executor with the `blocking.never` property. 
+
+
+  basic_system_executor< execution::blocking_t::never_t, Relationship, Allocator > require(
+      execution::blocking_t::never_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload4 basic_system_executor::require (4 of 7 overloads)]
+
+
+Obtain an executor with the `relationship.continuation` property. 
+
+
+  basic_system_executor< Blocking, execution::relationship_t::continuation_t, Allocator > require(
+      execution::relationship_t::continuation_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload5 basic_system_executor::require (5 of 7 overloads)]
+
+
+Obtain an executor with the `relationship.fork` property. 
+
+
+  basic_system_executor< Blocking, execution::relationship_t::fork_t, Allocator > require(
+      execution::relationship_t::fork_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload6 basic_system_executor::require (6 of 7 overloads)]
+
+
+Obtain an executor with the specified `allocator` property. 
+
+
+  template<
+      typename OtherAllocator>
+  basic_system_executor< Blocking, Relationship, OtherAllocator > require(
+      execution::allocator_t< OtherAllocator > a) const;
+
+
+
+[endsect]
+
+
+
+[section:overload7 basic_system_executor::require (7 of 7 overloads)]
+
+
+Obtain an executor with the default `allocator` property. 
+
+
+  basic_system_executor< Blocking, Relationship, std::allocator< void > > require(
+      execution::allocator_t< void > ) const;
+
+
+
+[endsect]
+
+
+[endsect]
+
+
 [endsect]
 
 [section:basic_waitable_timer basic_waitable_timer]
@@ -50840,8 +51609,15 @@ Move-construct a [link asio.reference.basic_waitable_timer `basic_waitable_timer
       basic_waitable_timer && other);
   ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.basic_waitable_timer.overload7 more...]]``
 
+  template<
+      typename ``[link asio.reference.Executor1 Executor1]``>
+  ``[link asio.reference.basic_waitable_timer.basic_waitable_timer.overload8 basic_waitable_timer]``(
+      basic_waitable_timer< Clock, WaitTraits, Executor1 > && other,
+      typename enable_if< is_convertible< Executor1, Executor >::value >::type *  = 0);
+  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.basic_waitable_timer.overload8 more...]]``
 
-[section:overload1 basic_waitable_timer::basic_waitable_timer (1 of 7 overloads)]
+
+[section:overload1 basic_waitable_timer::basic_waitable_timer (1 of 8 overloads)]
 
 
 Constructor. 
@@ -50870,7 +51646,7 @@ This constructor creates a timer without setting an expiry time. The `expires_at
 
 
 
-[section:overload2 basic_waitable_timer::basic_waitable_timer (2 of 7 overloads)]
+[section:overload2 basic_waitable_timer::basic_waitable_timer (2 of 8 overloads)]
 
 
 Constructor. 
@@ -50902,7 +51678,7 @@ This constructor creates a timer without setting an expiry time. The `expires_at
 
 
 
-[section:overload3 basic_waitable_timer::basic_waitable_timer (3 of 7 overloads)]
+[section:overload3 basic_waitable_timer::basic_waitable_timer (3 of 8 overloads)]
 
 
 Constructor to set a particular expiry time as an absolute time. 
@@ -50934,7 +51710,7 @@ This constructor creates a timer and sets the expiry time.
 
 
 
-[section:overload4 basic_waitable_timer::basic_waitable_timer (4 of 7 overloads)]
+[section:overload4 basic_waitable_timer::basic_waitable_timer (4 of 8 overloads)]
 
 
 Constructor to set a particular expiry time as an absolute time. 
@@ -50969,7 +51745,7 @@ This constructor creates a timer and sets the expiry time.
 
 
 
-[section:overload5 basic_waitable_timer::basic_waitable_timer (5 of 7 overloads)]
+[section:overload5 basic_waitable_timer::basic_waitable_timer (5 of 8 overloads)]
 
 
 Constructor to set a particular expiry time relative to now. 
@@ -51001,7 +51777,7 @@ This constructor creates a timer and sets the expiry time.
 
 
 
-[section:overload6 basic_waitable_timer::basic_waitable_timer (6 of 7 overloads)]
+[section:overload6 basic_waitable_timer::basic_waitable_timer (6 of 8 overloads)]
 
 
 Constructor to set a particular expiry time relative to now. 
@@ -51036,7 +51812,7 @@ This constructor creates a timer and sets the expiry time.
 
 
 
-[section:overload7 basic_waitable_timer::basic_waitable_timer (7 of 7 overloads)]
+[section:overload7 basic_waitable_timer::basic_waitable_timer (7 of 8 overloads)]
 
 
 Move-construct a [link asio.reference.basic_waitable_timer `basic_waitable_timer`] from another. 
@@ -51066,6 +51842,43 @@ Following the move, the moved-from object is in the same state as if constructed
 
 
 
+[endsect]
+
+
+
+[section:overload8 basic_waitable_timer::basic_waitable_timer (8 of 8 overloads)]
+
+
+Move-construct a [link asio.reference.basic_waitable_timer `basic_waitable_timer`] from another. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor1]``>
+  basic_waitable_timer(
+      basic_waitable_timer< Clock, WaitTraits, Executor1 > && other,
+      typename enable_if< is_convertible< Executor1, Executor >::value >::type *  = 0);
+
+
+This constructor moves a timer from one object to another.
+
+
+[heading Parameters]
+    
+
+[variablelist
+  
+[[other][The other [link asio.reference.basic_waitable_timer `basic_waitable_timer`] object from which the move will occur.]]
+
+]
+
+
+[heading Remarks]
+      
+Following the move, the moved-from object is in the same state as if constructed using the `basic_waitable_timer(const executor_type&)` constructor. 
+
+
+
+
 [endsect]
 
 
@@ -51733,10 +52546,26 @@ Get the executor associated with the object.
 [endsect]
 
 
-
 [section:operator_eq_ basic_waitable_timer::operator=]
 
 [indexterm2 asio.indexterm.basic_waitable_timer.operator_eq_..operator=..basic_waitable_timer] 
+Move-assign a [link asio.reference.basic_waitable_timer `basic_waitable_timer`] from another. 
+
+
+  basic_waitable_timer & ``[link asio.reference.basic_waitable_timer.operator_eq_.overload1 operator=]``(
+      basic_waitable_timer && other);
+  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.operator_eq_.overload1 more...]]``
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor1]``>
+  enable_if< is_convertible< Executor1, Executor >::value, basic_waitable_timer & >::type ``[link asio.reference.basic_waitable_timer.operator_eq_.overload2 operator=]``(
+      basic_waitable_timer< Clock, WaitTraits, Executor1 > && other);
+  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.operator_eq_.overload2 more...]]``
+
+
+[section:overload1 basic_waitable_timer::operator= (1 of 2 overloads)]
+
+
 Move-assign a [link asio.reference.basic_waitable_timer `basic_waitable_timer`] from another. 
 
 
@@ -51768,6 +52597,44 @@ Following the move, the moved-from object is in the same state as if constructed
 
 
 
+[section:overload2 basic_waitable_timer::operator= (2 of 2 overloads)]
+
+
+Move-assign a [link asio.reference.basic_waitable_timer `basic_waitable_timer`] from another. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor1]``>
+  enable_if< is_convertible< Executor1, Executor >::value, basic_waitable_timer & >::type operator=(
+      basic_waitable_timer< Clock, WaitTraits, Executor1 > && other);
+
+
+This assignment operator moves a timer from one object to another. Cancels any outstanding asynchronous operations associated with the target object.
+
+
+[heading Parameters]
+    
+
+[variablelist
+  
+[[other][The other [link asio.reference.basic_waitable_timer `basic_waitable_timer`] object from which the move will occur.]]
+
+]
+
+
+[heading Remarks]
+      
+Following the move, the moved-from object is in the same state as if constructed using the `basic_waitable_timer(const executor_type&)` constructor. 
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+
 [section:time_point basic_waitable_timer::time_point]
 
 [indexterm2 asio.indexterm.basic_waitable_timer.time_point..time_point..basic_waitable_timer] 
@@ -52431,7 +53298,7 @@ Associate an object of type `T` with an executor of type `Executor`.
   executor_binder< typename decay< T >::type, Executor > ``[link asio.reference.bind_executor.overload1 bind_executor]``(
       const Executor & ex,
       T && t,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.bind_executor.overload1 more...]]``
 
 Associate an object of type `T` with an execution context's executor. 
@@ -52464,7 +53331,7 @@ Associate an object of type `T` with an executor of type `Executor`.
   executor_binder< typename decay< T >::type, Executor > bind_executor(
       const Executor & ex,
       T && t,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
 
 
 
@@ -57513,34 +58380,172 @@ The type of the value pointed to by the iterator.
 
 
 
+[endsect]
+
+[section:can_prefer can_prefer]
+
+
+A type trait that determines whether a `prefer` expression is well-formed. 
+
+
+  template<
+      typename T,
+      typename... Properties>
+  struct can_prefer
+
+
+Class template `can_prefer` is a trait that is derived from `true_type` if the expression `asio::prefer(std::declval<T>(), std::declval<Properties>()...)` is well formed; otherwise `false_type`. 
+
+[heading Requirements]
+
+['Header: ][^asio/prefer.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+[section:can_query can_query]
+
+
+A type trait that determines whether a `query` expression is well-formed. 
+
+
+  template<
+      typename T,
+      typename Property>
+  struct can_query
+
+
+Class template `can_query` is a trait that is derived from `true_type` if the expression `asio::query(std::declval<T>(), std::declval<Property>())` is well formed; otherwise `false_type`. 
+
+[heading Requirements]
+
+['Header: ][^asio/query.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+[section:can_require can_require]
+
+
+A type trait that determines whether a `require` expression is well-formed. 
+
+
+  template<
+      typename T,
+      typename... Properties>
+  struct can_require
+
+
+Class template `can_require` is a trait that is derived from `true_type` if the expression `asio::require(std::declval<T>(), std::declval<Properties>()...)` is well formed; otherwise `false_type`. 
+
+[heading Requirements]
+
+['Header: ][^asio/require.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+[section:can_require_concept can_require_concept]
+
+
+A type trait that determines whether a `require_concept` expression is well-formed. 
+
+
+  template<
+      typename T,
+      typename Property>
+  struct can_require_concept
+
+
+Class template `can_require_concept` is a trait that is derived from `true_type` if the expression `asio::require_concept(std::declval<T>(), std::declval<Property>())` is well formed; otherwise `false_type`. 
+
+[heading Requirements]
+
+['Header: ][^asio/require_concept.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
 [endsect]
 
 [section:co_spawn co_spawn]
 
 [indexterm1 asio.indexterm.co_spawn..co_spawn] 
-Spawn a new thread of execution. 
+Spawn a new coroutined-based thread of execution. 
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor]``,
+      typename T,
+      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
+      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
+  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload1 co_spawn]``(
+      const Executor & ex,
+      awaitable< T, AwaitableExecutor > a,
+      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
+      typename enable_if< (is_executor< Executor >::value||execution::is_executor< Executor >::value)&&is_convertible< Executor, AwaitableExecutor >::value >::type *  = 0);
+  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload1 more...]]``
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor]``,
+      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
+      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
+  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload2 co_spawn]``(
+      const Executor & ex,
+      awaitable< void, AwaitableExecutor > a,
+      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
+      typename enable_if< (is_executor< Executor >::value||execution::is_executor< Executor >::value)&&is_convertible< Executor, AwaitableExecutor >::value >::type *  = 0);
+  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload2 more...]]``
+
+  template<
+      typename ExecutionContext,
+      typename T,
+      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
+      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
+  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload3 co_spawn]``(
+      ExecutionContext & ctx,
+      awaitable< T, AwaitableExecutor > a,
+      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
+      typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value &&is_convertible< typename ExecutionContext::executor_type, AwaitableExecutor >::value >::type *  = 0);
+  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload3 more...]]``
+
+  template<
+      typename ExecutionContext,
+      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
+      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
+  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload4 co_spawn]``(
+      ExecutionContext & ctx,
+      awaitable< void, AwaitableExecutor > a,
+      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
+      typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value &&is_convertible< typename ExecutionContext::executor_type, AwaitableExecutor >::value >::type *  = 0);
+  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload4 more...]]``
 
   template<
       typename ``[link asio.reference.Executor1 Executor]``,
       typename F,
       typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload1 co_spawn]``(
+  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload5 co_spawn]``(
       const Executor & ex,
       F && f,
       CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
-  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload1 more...]]``
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
+  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload5 more...]]``
 
   template<
       typename ExecutionContext,
       typename F,
       typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload2 co_spawn]``(
+  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload6 co_spawn]``(
       ExecutionContext & ctx,
       F && f,
       CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
-  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload2 more...]]``
+  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload6 more...]]``
 
 [heading Requirements]
 
@@ -57549,10 +58554,332 @@ Spawn a new thread of execution.
 ['Convenience header: ][^asio.hpp]
 
 
-[section:overload1 co_spawn (1 of 2 overloads)]
+[section:overload1 co_spawn (1 of 6 overloads)]
 
 
-Spawn a new thread of execution. 
+Spawn a new coroutined-based thread of execution. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor]``,
+      typename T,
+      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
+      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
+  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
+      const Executor & ex,
+      awaitable< T, AwaitableExecutor > a,
+      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
+      typename enable_if< (is_executor< Executor >::value||execution::is_executor< Executor >::value)&&is_convertible< Executor, AwaitableExecutor >::value >::type *  = 0);
+
+
+
+[heading Parameters]
+    
+
+[variablelist
+  
+[[ex][The executor that will be used to schedule the new thread of execution.]]
+
+[[a][The [link asio.reference.awaitable `awaitable`] object that is the result of calling the coroutine's entry point function.]]
+
+[[token][The completion token that will handle the notification that the thread of execution has completed. The function signature of the completion handler must be: 
+``
+   void handler(std::exception_ptr, T); 
+``
+]]
+
+]
+
+
+[heading Example]
+  
+
+
+   asio::awaitable<std::size_t> echo(tcp::socket socket)
+   {
+     std::size_t bytes_transferred = 0;
+
+     try
+     {
+       char data[1024];
+       for (;;)
+       {
+         std::size_t n = co_await socket.async_read_some(
+             asio::buffer(data), asio::use_awaitable);
+
+         co_await asio::async_write(socket,
+             asio::buffer(data, n), asio::use_awaitable);
+
+         bytes_transferred += n;
+       }
+     }
+     catch (const std::exception&)
+     {
+     }
+
+     co_return bytes_transferred;
+   }
+
+   // ...
+
+   asio::co_spawn(my_executor,
+     echo(std::move(my_tcp_socket)),
+     [](std::exception_ptr e, std::size_t n)
+     {
+       std::cout << "transferred " << n << "\n";
+     });
+
+
+
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 co_spawn (2 of 6 overloads)]
+
+
+Spawn a new coroutined-based thread of execution. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor]``,
+      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
+      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
+  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
+      const Executor & ex,
+      awaitable< void, AwaitableExecutor > a,
+      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
+      typename enable_if< (is_executor< Executor >::value||execution::is_executor< Executor >::value)&&is_convertible< Executor, AwaitableExecutor >::value >::type *  = 0);
+
+
+
+[heading Parameters]
+    
+
+[variablelist
+  
+[[ex][The executor that will be used to schedule the new thread of execution.]]
+
+[[a][The [link asio.reference.awaitable `awaitable`] object that is the result of calling the coroutine's entry point function.]]
+
+[[token][The completion token that will handle the notification that the thread of execution has completed. The function signature of the completion handler must be: 
+``
+   void handler(std::exception_ptr); 
+``
+]]
+
+]
+
+
+[heading Example]
+  
+
+
+   asio::awaitable<void> echo(tcp::socket socket)
+   {
+     try
+     {
+       char data[1024];
+       for (;;)
+       {
+         std::size_t n = co_await socket.async_read_some(
+             asio::buffer(data), asio::use_awaitable);
+
+         co_await asio::async_write(socket,
+             asio::buffer(data, n), asio::use_awaitable);
+       }
+     }
+     catch (const std::exception& e)
+     {
+       std::cerr << "Exception: " << e.what() << "\n";
+     }
+   }
+
+   // ...
+
+   asio::co_spawn(my_executor,
+     echo(std::move(my_tcp_socket)),
+     asio::detached);
+
+
+
+
+
+
+
+[endsect]
+
+
+
+[section:overload3 co_spawn (3 of 6 overloads)]
+
+
+Spawn a new coroutined-based thread of execution. 
+
+
+  template<
+      typename ExecutionContext,
+      typename T,
+      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
+      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
+  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
+      ExecutionContext & ctx,
+      awaitable< T, AwaitableExecutor > a,
+      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
+      typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value &&is_convertible< typename ExecutionContext::executor_type, AwaitableExecutor >::value >::type *  = 0);
+
+
+
+[heading Parameters]
+    
+
+[variablelist
+  
+[[ctx][An execution context that will provide the executor to be used to schedule the new thread of execution.]]
+
+[[a][The [link asio.reference.awaitable `awaitable`] object that is the result of calling the coroutine's entry point function.]]
+
+[[token][The completion token that will handle the notification that the thread of execution has completed. The function signature of the completion handler must be: 
+``
+   void handler(std::exception_ptr); 
+``
+]]
+
+]
+
+
+[heading Example]
+  
+
+
+   asio::awaitable<std::size_t> echo(tcp::socket socket)
+   {
+     std::size_t bytes_transferred = 0;
+
+     try
+     {
+       char data[1024];
+       for (;;)
+       {
+         std::size_t n = co_await socket.async_read_some(
+             asio::buffer(data), asio::use_awaitable);
+
+         co_await asio::async_write(socket,
+             asio::buffer(data, n), asio::use_awaitable);
+
+         bytes_transferred += n;
+       }
+     }
+     catch (const std::exception&)
+     {
+     }
+
+     co_return bytes_transferred;
+   }
+
+   // ...
+
+   asio::co_spawn(my_io_context,
+     echo(std::move(my_tcp_socket)),
+     [](std::exception_ptr e, std::size_t n)
+     {
+       std::cout << "transferred " << n << "\n";
+     });
+
+
+
+
+
+
+
+[endsect]
+
+
+
+[section:overload4 co_spawn (4 of 6 overloads)]
+
+
+Spawn a new coroutined-based thread of execution. 
+
+
+  template<
+      typename ExecutionContext,
+      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
+      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
+  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
+      ExecutionContext & ctx,
+      awaitable< void, AwaitableExecutor > a,
+      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
+      typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value &&is_convertible< typename ExecutionContext::executor_type, AwaitableExecutor >::value >::type *  = 0);
+
+
+
+[heading Parameters]
+    
+
+[variablelist
+  
+[[ctx][An execution context that will provide the executor to be used to schedule the new thread of execution.]]
+
+[[a][The [link asio.reference.awaitable `awaitable`] object that is the result of calling the coroutine's entry point function.]]
+
+[[token][The completion token that will handle the notification that the thread of execution has completed. The function signature of the completion handler must be: 
+``
+   void handler(std::exception_ptr); 
+``
+]]
+
+]
+
+
+[heading Example]
+  
+
+
+   asio::awaitable<void> echo(tcp::socket socket)
+   {
+     try
+     {
+       char data[1024];
+       for (;;)
+       {
+         std::size_t n = co_await socket.async_read_some(
+             asio::buffer(data), asio::use_awaitable);
+
+         co_await asio::async_write(socket,
+             asio::buffer(data, n), asio::use_awaitable);
+       }
+     }
+     catch (const std::exception& e)
+     {
+       std::cerr << "Exception: " << e.what() << "\n";
+     }
+   }
+
+   // ...
+
+   asio::co_spawn(my_io_context,
+     echo(std::move(my_tcp_socket)),
+     asio::detached);
+
+
+
+
+
+
+
+[endsect]
+
+
+
+[section:overload5 co_spawn (5 of 6 overloads)]
+
+
+Spawn a new coroutined-based thread of execution. 
 
 
   template<
@@ -57563,29 +58890,103 @@ Spawn a new thread of execution.
       const Executor & ex,
       F && f,
       CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
-
-
-The entry point function object `f` must have the signature:
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
 
 
 
-   awaitable<void, E> f(); 
+[heading Parameters]
+    
+
+[variablelist
+  
+[[ex][The executor that will be used to schedule the new thread of execution.]]
+
+[[f][A nullary function object with a return type of the form `asio::awaitable<R,E>` that will be used as the coroutine's entry point.]]
+
+[[token][The completion token that will handle the notification that the thread of execution has completed. If `R` is `void`, the function signature of the completion handler must be:]]
+
+]
+
+
+
+   void handler(std::exception_ptr); 
+
+
+Otherwise, the function signature of the completion handler must be: 
+
+   void handler(std::exception_ptr, R); 
+
+
+
+
+
+[heading Example]
+  
+
+
+   asio::awaitable<std::size_t> echo(tcp::socket socket)
+   {
+     std::size_t bytes_transferred = 0;
+
+     try
+     {
+       char data[1024];
+       for (;;)
+       {
+         std::size_t n = co_await socket.async_read_some(
+             asio::buffer(data), asio::use_awaitable);
+
+         co_await asio::async_write(socket,
+             asio::buffer(data, n), asio::use_awaitable);
+
+         bytes_transferred += n;
+       }
+     }
+     catch (const std::exception&)
+     {
+     }
+
+     co_return bytes_transferred;
+   }
+
+   // ...
+
+   asio::co_spawn(my_executor,
+     [socket = std::move(my_tcp_socket)]() mutable
+       -> asio::awaitable<void>
+     {
+       try
+       {
+         char data[1024];
+         for (;;)
+         {
+           std::size_t n = co_await socket.async_read_some(
+               asio::buffer(data), asio::use_awaitable);
+
+           co_await asio::async_write(socket,
+               asio::buffer(data, n), asio::use_awaitable);
+         }
+       }
+       catch (const std::exception& e)
+       {
+         std::cerr << "Exception: " << e.what() << "\n";
+       }
+     }, asio::detached);
+
 
 
 
 
-where `E` is convertible from `Executor`. 
 
 
 [endsect]
 
 
 
-[section:overload2 co_spawn (2 of 2 overloads)]
+[section:overload6 co_spawn (6 of 6 overloads)]
 
 
-Spawn a new thread of execution. 
+Spawn a new coroutined-based thread of execution. 
 
 
   template<
@@ -57599,16 +59000,90 @@ Spawn a new thread of execution.
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
 
 
-The entry point function object `f` must have the signature:
+
+[heading Parameters]
+    
+
+[variablelist
+  
+[[ctx][An execution context that will provide the executor to be used to schedule the new thread of execution.]]
+
+[[f][A nullary function object with a return type of the form `asio::awaitable<R,E>` that will be used as the coroutine's entry point.]]
+
+[[token][The completion token that will handle the notification that the thread of execution has completed. If `R` is `void`, the function signature of the completion handler must be:]]
+
+]
 
 
 
-   awaitable<void, E> f(); 
+   void handler(std::exception_ptr); 
+
+
+Otherwise, the function signature of the completion handler must be: 
+
+   void handler(std::exception_ptr, R); 
+
+
+
+
+
+[heading Example]
+  
+
+
+   asio::awaitable<std::size_t> echo(tcp::socket socket)
+   {
+     std::size_t bytes_transferred = 0;
+
+     try
+     {
+       char data[1024];
+       for (;;)
+       {
+         std::size_t n = co_await socket.async_read_some(
+             asio::buffer(data), asio::use_awaitable);
+
+         co_await asio::async_write(socket,
+             asio::buffer(data, n), asio::use_awaitable);
+
+         bytes_transferred += n;
+       }
+     }
+     catch (const std::exception&)
+     {
+     }
+
+     co_return bytes_transferred;
+   }
+
+   // ...
+
+   asio::co_spawn(my_io_context,
+     [socket = std::move(my_tcp_socket)]() mutable
+       -> asio::awaitable<void>
+     {
+       try
+       {
+         char data[1024];
+         for (;;)
+         {
+           std::size_t n = co_await socket.async_read_some(
+               asio::buffer(data), asio::use_awaitable);
+
+           co_await asio::async_write(socket,
+               asio::buffer(data, n), asio::use_awaitable);
+         }
+       }
+       catch (const std::exception& e)
+       {
+         std::cerr << "Exception: " << e.what() << "\n";
+       }
+     }, asio::detached);
+
 
 
 
 
-where `E` is convertible from `ExecutionContext::executor_type`. 
 
 
 [endsect]
@@ -59944,7 +61419,7 @@ Submits a completion token or function object for execution.
   ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.defer.overload2 defer]``(
       const Executor & ex,
       CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< execution::is_executor< Executor >::value||is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.defer.overload2 more...]]``
 
   template<
@@ -60018,7 +61493,7 @@ Submits a completion token or function object for execution.
   ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` defer(
       const Executor & ex,
       CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< execution::is_executor< Executor >::value||is_executor< Executor >::value >::type *  = 0);
 
 
 This function submits an object for execution using the specified executor. The function object is queued for execution, and is never called from the current thread prior to returning from `defer()`.
@@ -60117,10 +61592,28 @@ Class used to specify that an asynchronous operation is detached.
   class detached_t
 
 
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.detached_t__executor_with_default [*executor_with_default]]]
+    [Adapts an executor to add the detached_t completion token as the default. ]
+  
+  ]
+
+]
+
 [heading Member Functions]
 [table
   [[Name][Description]]
 
+  [
+    [[link asio.reference.detached_t.as_default_on [*as_default_on]]]
+    [Function helper to adapt an I/O object to use detached_t as its default completion token type. ]
+  ]
+  
   [
     [[link asio.reference.detached_t.detached_t [*detached_t]]]
     [Constructor. ]
@@ -60144,6 +61637,23 @@ The [link asio.reference.detached_t `detached_t`] class is used to indicate that
 ['Convenience header: ][^asio.hpp]
 
 
+[section:as_default_on detached_t::as_default_on]
+
+[indexterm2 asio.indexterm.detached_t.as_default_on..as_default_on..detached_t] 
+Function helper to adapt an I/O object to use `detached_t` as its default completion token type. 
+
+
+  template<
+      typename T>
+  static decay< T >::type::template rebind_executor< executor_with_default< typename decay< T >::type::executor_type > >::other as_default_on(
+      T && object);
+
+
+
+[endsect]
+
+
+
 [section:detached_t detached_t::detached_t]
 
 [indexterm2 asio.indexterm.detached_t.detached_t..detached_t..detached_t] 
@@ -60158,6 +61668,167 @@ Constructor.
 
 
 
+[endsect]
+
+[section:detached_t__executor_with_default detached_t::executor_with_default]
+
+
+Adapts an executor to add the `detached_t` completion token as the default. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 InnerExecutor]``>
+  struct executor_with_default
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.detached_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
+    [Specify detached_t as the default completion token type. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.detached_t__executor_with_default.executor_with_default [*executor_with_default]]]
+    [Construct the adapted executor from the inner executor type. 
+     [hr]
+     Convert the specified executor to the inner executor type, then use that to construct the adapted executor. ]
+  ]
+  
+]
+
+[heading Requirements]
+
+['Header: ][^asio/detached.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[section:default_completion_token_type detached_t::executor_with_default::default_completion_token_type]
+
+[indexterm2 asio.indexterm.detached_t__executor_with_default.default_completion_token_type..default_completion_token_type..detached_t::executor_with_default] 
+Specify `detached_t` as the default completion token type. 
+
+
+  typedef detached_t default_completion_token_type;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.detached_t__executor_with_default [*executor_with_default]]]
+    [Adapts an executor to add the detached_t completion token as the default. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.detached_t.as_default_on [*as_default_on]]]
+    [Function helper to adapt an I/O object to use detached_t as its default completion token type. ]
+  ]
+  
+  [
+    [[link asio.reference.detached_t.detached_t [*detached_t]]]
+    [Constructor. ]
+  ]
+  
+]
+
+The [link asio.reference.detached_t `detached_t`] class is used to indicate that an asynchronous operation is detached. That is, there is no completion handler waiting for the operation's result. A [link asio.reference.detached_t `detached_t`] object may be passed as a handler to an asynchronous operation, typically using the special value `asio::detached`. For example:
+
+
+
+   my_socket.async_send(my_buffer, asio::detached);
+
+
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/detached.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+[section:executor_with_default detached_t::executor_with_default::executor_with_default]
+
+[indexterm2 asio.indexterm.detached_t__executor_with_default.executor_with_default..executor_with_default..detached_t::executor_with_default] 
+Construct the adapted executor from the inner executor type. 
+
+
+  ``[link asio.reference.detached_t__executor_with_default.executor_with_default.overload1 executor_with_default]``(
+      const InnerExecutor & ex);
+  ``  [''''&raquo;''' [link asio.reference.detached_t__executor_with_default.executor_with_default.overload1 more...]]``
+
+
+Convert the specified executor to the inner executor type, then use that to construct the adapted executor. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 OtherExecutor]``>
+  ``[link asio.reference.detached_t__executor_with_default.executor_with_default.overload2 executor_with_default]``(
+      const OtherExecutor & ex,
+      typename enable_if< is_convertible< OtherExecutor, InnerExecutor >::value >::type *  = 0);
+  ``  [''''&raquo;''' [link asio.reference.detached_t__executor_with_default.executor_with_default.overload2 more...]]``
+
+
+[section:overload1 detached_t::executor_with_default::executor_with_default (1 of 2 overloads)]
+
+
+Construct the adapted executor from the inner executor type. 
+
+
+  executor_with_default(
+      const InnerExecutor & ex);
+
+
+
+[endsect]
+
+
+
+[section:overload2 detached_t::executor_with_default::executor_with_default (2 of 2 overloads)]
+
+
+Convert the specified executor to the inner executor type, then use that to construct the adapted executor. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 OtherExecutor]``>
+  executor_with_default(
+      const OtherExecutor & ex,
+      typename enable_if< is_convertible< OtherExecutor, InnerExecutor >::value >::type *  = 0);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
 [endsect]
 
 [section:dispatch dispatch]
@@ -60177,7 +61848,7 @@ Submits a completion token or function object for execution.
   ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.dispatch.overload2 dispatch]``(
       const Executor & ex,
       CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< execution::is_executor< Executor >::value||is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.dispatch.overload2 more...]]``
 
   template<
@@ -60249,7 +61920,7 @@ Submits a completion token or function object for execution.
   ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` dispatch(
       const Executor & ex,
       CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< execution::is_executor< Executor >::value||is_executor< Executor >::value >::type *  = 0);
 
 
 This function submits an object for execution using the specified executor. The function object may be called from the current thread prior to returning from `dispatch()`. Otherwise, it is queued for execution.
@@ -63005,6 +64676,6015 @@ Get the error value.
 ['Convenience header: ][^asio.hpp]
 
 
+[endsect]
+
+
+[section:execution__allocator execution::allocator]
+
+[indexterm1 asio.indexterm.execution__allocator..execution::allocator] 
+A special value used for accessing the [link asio.reference.execution__allocator_t `execution::allocator_t`] property. 
+
+
+  constexpr allocator_t< void > allocator;
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/allocator.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+[section:execution__allocator_t execution::allocator_t]
+
+
+A property that is used to obtain the execution context that is associated with an executor. 
+
+
+  template<
+      typename ``[link asio.reference.ProtoAllocator ProtoAllocator]``>
+  struct allocator_t
+
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__allocator_t.allocator_t [*allocator_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__allocator_t.value [*value]]]
+    [Obtain the allocator stored in the allocator_t property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__allocator_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The allocator_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__allocator_t.is_preferable [*is_preferable]]]
+    [The allocator_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__allocator_t.is_requirable [*is_requirable]]]
+    [The allocator_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/allocator.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:allocator_t execution::allocator_t::allocator_t]
+
+[indexterm2 asio.indexterm.execution__allocator_t.allocator_t..allocator_t..execution::allocator_t] 
+Default constructor. 
+
+
+  constexpr allocator_t();
+
+
+
+[endsect]
+
+
+
+[section:is_applicable_property_v execution::allocator_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__allocator_t.is_applicable_property_v..is_applicable_property_v..execution::allocator_t] 
+The [link asio.reference.execution__allocator_t `execution::allocator_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::allocator_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__allocator_t.is_preferable..is_preferable..execution::allocator_t] 
+The [link asio.reference.execution__allocator_t `execution::allocator_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::allocator_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__allocator_t.is_requirable..is_requirable..execution::allocator_t] 
+The [link asio.reference.execution__allocator_t `execution::allocator_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:value execution::allocator_t::value]
+
+[indexterm2 asio.indexterm.execution__allocator_t.value..value..execution::allocator_t] 
+Obtain the allocator stored in the [link asio.reference.execution__allocator_t `execution::allocator_t`] property object. 
+
+
+  constexpr ProtoAllocator value() const;
+
+
+Present only if `ProtoAllocator` is non-void. 
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__any_executor execution::any_executor]
+
+
+Polymorphic executor wrapper. 
+
+
+  template<
+      typename... SupportableProperties>
+  class any_executor
+
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__any_executor.any_executor [*any_executor]]]
+    [Default constructor. 
+     [hr]
+     Copy constructor. 
+     [hr]
+     Move constructor. 
+     [hr]
+     Construct to point to the same target as another any_executor. 
+     [hr]
+     Construct a polymorphic wrapper for the specified executor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.context [*context]]]
+    [Obtain the underlying execution context. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.execute [*execute]]]
+    [Execute the function on the target executor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.operator_bool [*operator bool]]]
+    [Determine whether the wrapper has a target executor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.operator_eq_ [*operator=]]]
+    [Assignment operator. 
+     [hr]
+     Move assignment operator. 
+     [hr]
+     Assignment operator to create a polymorphic wrapper for the specified executor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.prefer [*prefer]]]
+    [Obtain a polymorphic wrapper with the specified property. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.query [*query]]]
+    [Obtain the value associated with the specified property. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.require [*require]]]
+    [Obtain a polymorphic wrapper with the specified property. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.target [*target]]]
+    [Get a pointer to the target executor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.target_type [*target_type]]]
+    [Get the type of the target executor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor._any_executor [*~any_executor]]]
+    [Destructor. ]
+  ]
+  
+]
+
+[heading Related Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__any_executor.operator_not__eq_ [*operator!=]]]
+    [Inequality operator. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__any_executor.operator_eq__eq_ [*operator==]]]
+    [Equality operator. ]
+  ]
+  
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/any_executor.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+[section:any_executor execution::any_executor::any_executor]
+
+[indexterm2 asio.indexterm.execution__any_executor.any_executor..any_executor..execution::any_executor] 
+Default constructor. 
+
+
+  ``[link asio.reference.execution__any_executor.any_executor.overload1 any_executor]``();
+  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload1 more...]]``
+
+
+Copy constructor. 
+
+
+  ``[link asio.reference.execution__any_executor.any_executor.overload2 any_executor]``(
+      const any_executor & e);
+  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload2 more...]]``
+
+
+Move constructor. 
+
+
+  ``[link asio.reference.execution__any_executor.any_executor.overload3 any_executor]``(
+      any_executor && e);
+  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload3 more...]]``
+
+
+Construct to point to the same target as another [link asio.reference.execution__any_executor `execution::any_executor`]. 
+
+
+  template<
+      class... OtherSupportableProperties>
+  ``[link asio.reference.execution__any_executor.any_executor.overload4 any_executor]``(
+      any_executor< OtherSupportableProperties...> e);
+  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload4 more...]]``
+
+
+Construct a polymorphic wrapper for the specified executor. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor]``>
+  ``[link asio.reference.execution__any_executor.any_executor.overload5 any_executor]``(
+      Executor e);
+  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload5 more...]]``
+
+
+[section:overload1 execution::any_executor::any_executor (1 of 5 overloads)]
+
+
+Default constructor. 
+
+
+  any_executor();
+
+
+
+[endsect]
+
+
+
+[section:overload2 execution::any_executor::any_executor (2 of 5 overloads)]
+
+
+Copy constructor. 
+
+
+  any_executor(
+      const any_executor & e);
+
+
+
+[endsect]
+
+
+
+[section:overload3 execution::any_executor::any_executor (3 of 5 overloads)]
+
+
+Move constructor. 
+
+
+  any_executor(
+      any_executor && e);
+
+
+
+[endsect]
+
+
+
+[section:overload4 execution::any_executor::any_executor (4 of 5 overloads)]
+
+
+Construct to point to the same target as another [link asio.reference.execution__any_executor `execution::any_executor`]. 
+
+
+  template<
+      class... OtherSupportableProperties>
+  any_executor(
+      any_executor< OtherSupportableProperties...> e);
+
+
+
+[endsect]
+
+
+
+[section:overload5 execution::any_executor::any_executor (5 of 5 overloads)]
+
+
+Construct a polymorphic wrapper for the specified executor. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor]``>
+  any_executor(
+      Executor e);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:context execution::any_executor::context]
+
+[indexterm2 asio.indexterm.execution__any_executor.context..context..execution::any_executor] 
+Obtain the underlying execution context. 
+
+
+  automatically_determined context() const;
+
+
+This function is provided for backward compatibility. It is automatically defined when the `SupportableProperties`... list includes a property of type `execution::context_as<U>`, for some type `U`. 
+
+
+[endsect]
+
+
+
+[section:execute execution::any_executor::execute]
+
+[indexterm2 asio.indexterm.execution__any_executor.execute..execute..execution::any_executor] 
+Execute the function on the target executor. 
+
+
+  template<
+      typename Function>
+  void execute(
+      Function && f) const;
+
+
+Do not call this function directly. It is intended for use with the [link asio.reference.execution__execute `execution::execute`] customisation point.
+
+For example: 
+
+   execution::any_executor<> ex = ...;
+   execution::execute(ex, my_function_object); 
+
+
+
+
+Throws [link asio.reference.bad_executor `bad_executor`] if the polymorphic wrapper has no target. 
+
+
+[endsect]
+
+
+
+[section:operator_bool execution::any_executor::operator bool]
+
+[indexterm2 asio.indexterm.execution__any_executor.operator_bool..operator bool..execution::any_executor] 
+Determine whether the wrapper has a target executor. 
+
+
+  operator bool() const;
+
+
+
+[heading Return Value]
+      
+`true` if the polymorphic wrapper has a target executor, otherwise false. 
+
+
+
+
+[endsect]
+
+
+
+[section:operator_not__eq_ execution::any_executor::operator!=]
+
+[indexterm2 asio.indexterm.execution__any_executor.operator_not__eq_..operator!=..execution::any_executor] 
+Inequality operator. 
+
+
+  bool operator!=(
+      const any_executor< SupportableProperties...> & a,
+      const any_executor< SupportableProperties...> & b);
+
+
+
+[endsect]
+
+
+[section:operator_eq_ execution::any_executor::operator=]
+
+[indexterm2 asio.indexterm.execution__any_executor.operator_eq_..operator=..execution::any_executor] 
+Assignment operator. 
+
+
+  any_executor & ``[link asio.reference.execution__any_executor.operator_eq_.overload1 operator=]``(
+      const any_executor & e);
+  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.operator_eq_.overload1 more...]]``
+
+
+Move assignment operator. 
+
+
+  any_executor & ``[link asio.reference.execution__any_executor.operator_eq_.overload2 operator=]``(
+      any_executor && e);
+  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.operator_eq_.overload2 more...]]``
+
+
+Assignment operator to create a polymorphic wrapper for the specified executor. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor]``>
+  any_executor & ``[link asio.reference.execution__any_executor.operator_eq_.overload3 operator=]``(
+      Executor e);
+  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.operator_eq_.overload3 more...]]``
+
+
+[section:overload1 execution::any_executor::operator= (1 of 3 overloads)]
+
+
+Assignment operator. 
+
+
+  any_executor & operator=(
+      const any_executor & e);
+
+
+
+[endsect]
+
+
+
+[section:overload2 execution::any_executor::operator= (2 of 3 overloads)]
+
+
+Move assignment operator. 
+
+
+  any_executor & operator=(
+      any_executor && e);
+
+
+
+[endsect]
+
+
+
+[section:overload3 execution::any_executor::operator= (3 of 3 overloads)]
+
+
+Assignment operator to create a polymorphic wrapper for the specified executor. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor]``>
+  any_executor & operator=(
+      Executor e);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:operator_eq__eq_ execution::any_executor::operator==]
+
+[indexterm2 asio.indexterm.execution__any_executor.operator_eq__eq_..operator==..execution::any_executor] 
+Equality operator. 
+
+
+  bool operator==(
+      const any_executor< SupportableProperties...> & a,
+      const any_executor< SupportableProperties...> & b);
+
+
+
+[endsect]
+
+
+
+[section:prefer execution::any_executor::prefer]
+
+[indexterm2 asio.indexterm.execution__any_executor.prefer..prefer..execution::any_executor] 
+Obtain a polymorphic wrapper with the specified property. 
+
+
+  template<
+      typename Property>
+  any_executor prefer(
+      Property ) const;
+
+
+Do not call this function directly. It is intended for use with the [link asio.reference.prefer `prefer`] customisation point.
+
+For example: 
+
+   execution::any_executor<execution::blocking_t::possibly_t> ex = ...;
+   auto ex2 = asio::prefer(ex, execution::blocking.possibly); 
+
+
+
+
+
+[endsect]
+
+
+
+[section:query execution::any_executor::query]
+
+[indexterm2 asio.indexterm.execution__any_executor.query..query..execution::any_executor] 
+Obtain the value associated with the specified property. 
+
+
+  template<
+      typename Property>
+  Property::polymorphic_query_result_type query(
+      Property ) const;
+
+
+Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
+
+For example: 
+
+   execution::any_executor<execution::occupancy_t> ex = ...;
+   size_t n = asio::query(ex, execution::occupancy); 
+
+
+
+
+
+[endsect]
+
+
+
+[section:require execution::any_executor::require]
+
+[indexterm2 asio.indexterm.execution__any_executor.require..require..execution::any_executor] 
+Obtain a polymorphic wrapper with the specified property. 
+
+
+  template<
+      typename Property>
+  any_executor require(
+      Property ) const;
+
+
+Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] and [link asio.reference.prefer `prefer`] customisation points.
+
+For example: 
+
+   execution::any_executor<execution::blocking_t::possibly_t> ex = ...;
+   auto ex2 = asio::requre(ex, execution::blocking.possibly); 
+
+
+
+
+
+[endsect]
+
+
+[section:target execution::any_executor::target]
+
+[indexterm2 asio.indexterm.execution__any_executor.target..target..execution::any_executor] 
+Get a pointer to the target executor. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor]``>
+  Executor * ``[link asio.reference.execution__any_executor.target.overload1 target]``();
+  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.target.overload1 more...]]``
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor]``>
+  const Executor * ``[link asio.reference.execution__any_executor.target.overload2 target]``() const;
+  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.target.overload2 more...]]``
+
+
+[section:overload1 execution::any_executor::target (1 of 2 overloads)]
+
+
+Get a pointer to the target executor. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor]``>
+  Executor * target();
+
+
+
+[endsect]
+
+
+
+[section:overload2 execution::any_executor::target (2 of 2 overloads)]
+
+
+Get a pointer to the target executor. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 Executor]``>
+  const Executor * target() const;
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:target_type execution::any_executor::target_type]
+
+[indexterm2 asio.indexterm.execution__any_executor.target_type..target_type..execution::any_executor] 
+Get the type of the target executor. 
+
+
+  const type_info & target_type() const;
+
+
+
+[endsect]
+
+
+
+[section:_any_executor execution::any_executor::~any_executor]
+
+[indexterm2 asio.indexterm.execution__any_executor._any_executor..~any_executor..execution::any_executor] 
+Destructor. 
+
+
+  ~any_executor();
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__bad_executor execution::bad_executor]
+
+
+Exception thrown when trying to access an empty polymorphic executor. 
+
+
+  class bad_executor :
+    public std::exception
+
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__bad_executor.bad_executor [*bad_executor]]]
+    [Constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__bad_executor.what [*what]]]
+    [Obtain message associated with exception. ]
+  ]
+  
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/bad_executor.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:bad_executor execution::bad_executor::bad_executor]
+
+[indexterm2 asio.indexterm.execution__bad_executor.bad_executor..bad_executor..execution::bad_executor] 
+Constructor. 
+
+
+  bad_executor();
+
+
+
+[endsect]
+
+
+
+[section:what execution::bad_executor::what]
+
+[indexterm2 asio.indexterm.execution__bad_executor.what..what..execution::bad_executor] 
+Obtain message associated with exception. 
+
+
+  virtual const char * what() const;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:execution__blocking execution::blocking]
+
+[indexterm1 asio.indexterm.execution__blocking..execution::blocking] 
+A special value used for accessing the [link asio.reference.execution__blocking_t `execution::blocking_t`] property. 
+
+
+  constexpr blocking_t blocking;
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:execution__blocking_adaptation execution::blocking_adaptation]
+
+[indexterm1 asio.indexterm.execution__blocking_adaptation..execution::blocking_adaptation] 
+A special value used for accessing the [link asio.reference.execution__blocking_adaptation_t `execution::blocking_adaptation_t`] property. 
+
+
+  constexpr blocking_adaptation_t blocking_adaptation;
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking_adaptation.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+[section:execution__blocking_adaptation_t execution::blocking_adaptation_t]
+
+
+A property to describe whether automatic adaptation of an executor is allowed in order to apply the [link asio.reference.execution__blocking_adaptation_t__allowed_t `execution::blocking_adaptation_t::allowed_t`] property. 
+
+
+  struct blocking_adaptation_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__blocking_adaptation_t__allowed_t [*allowed_t]]]
+    [A sub-property that indicates that automatic adaptation is allowed. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t [*disallowed_t]]]
+    [A sub-property that indicates that automatic adaptation is not allowed. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__blocking_adaptation_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t [*blocking_adaptation_t]]]
+    [Default constructor. 
+     [hr]
+     Construct from a sub-property value. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t.allowed [*allowed]]]
+    [A special value used for accessing the blocking_adaptation_t::allowed_t property. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t.disallowed [*disallowed]]]
+    [A special value used for accessing the blocking_adaptation_t::disallowed_t property. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The blocking_adaptation_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t.is_preferable [*is_preferable]]]
+    [The top-level blocking_adaptation_t property cannot be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t.is_requirable [*is_requirable]]]
+    [The top-level blocking_adaptation_t property cannot be required. ]
+  ]
+
+]
+
+[heading Friends]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t.operator_not__eq_ [*operator!=]]]
+    [Compare property values for inequality. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__blocking_adaptation_t.operator_eq__eq_ [*operator==]]]
+    [Compare property values for equality. ]
+  ]
+  
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking_adaptation.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:allowed execution::blocking_adaptation_t::allowed]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t.allowed..allowed..execution::blocking_adaptation_t] 
+A special value used for accessing the [link asio.reference.execution__blocking_adaptation_t__allowed_t `execution::blocking_adaptation_t::allowed_t`] property. 
+
+
+  static constexpr allowed_t allowed;
+
+
+
+[endsect]
+
+
+[section:blocking_adaptation_t execution::blocking_adaptation_t::blocking_adaptation_t]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t.blocking_adaptation_t..blocking_adaptation_t..execution::blocking_adaptation_t] 
+Default constructor. 
+
+
+  constexpr ``[link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t.overload1 blocking_adaptation_t]``();
+  ``  [''''&raquo;''' [link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t.overload1 more...]]``
+
+
+Construct from a sub-property value. 
+
+
+  constexpr ``[link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t.overload2 blocking_adaptation_t]``(
+      disallowed_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t.overload2 more...]]``
+
+  constexpr ``[link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t.overload3 blocking_adaptation_t]``(
+      allowed_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t.overload3 more...]]``
+
+
+[section:overload1 execution::blocking_adaptation_t::blocking_adaptation_t (1 of 3 overloads)]
+
+
+Default constructor. 
+
+
+  constexpr blocking_adaptation_t();
+
+
+
+[endsect]
+
+
+
+[section:overload2 execution::blocking_adaptation_t::blocking_adaptation_t (2 of 3 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr blocking_adaptation_t(
+      disallowed_t );
+
+
+
+[endsect]
+
+
+
+[section:overload3 execution::blocking_adaptation_t::blocking_adaptation_t (3 of 3 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr blocking_adaptation_t(
+      allowed_t );
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:disallowed execution::blocking_adaptation_t::disallowed]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t.disallowed..disallowed..execution::blocking_adaptation_t] 
+A special value used for accessing the [link asio.reference.execution__blocking_adaptation_t__disallowed_t `execution::blocking_adaptation_t::disallowed_t`] property. 
+
+
+  static constexpr disallowed_t disallowed;
+
+
+
+[endsect]
+
+
+
+[section:is_applicable_property_v execution::blocking_adaptation_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_adaptation_t] 
+The [link asio.reference.execution__blocking_adaptation_t `execution::blocking_adaptation_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::blocking_adaptation_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t.is_preferable..is_preferable..execution::blocking_adaptation_t] 
+The top-level [link asio.reference.execution__blocking_adaptation_t `execution::blocking_adaptation_t`] property cannot be preferred. 
+
+
+  static constexpr bool is_preferable = false;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::blocking_adaptation_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t.is_requirable..is_requirable..execution::blocking_adaptation_t] 
+The top-level [link asio.reference.execution__blocking_adaptation_t `execution::blocking_adaptation_t`] property cannot be required. 
+
+
+  static constexpr bool is_requirable = false;
+
+
+
+[endsect]
+
+
+
+[section:operator_not__eq_ execution::blocking_adaptation_t::operator!=]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t.operator_not__eq_..operator!=..execution::blocking_adaptation_t] 
+Compare property values for inequality. 
+
+
+  friend constexpr bool operator!=(
+      const blocking_adaptation_t & a,
+      const blocking_adaptation_t & b);
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking_adaptation.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:operator_eq__eq_ execution::blocking_adaptation_t::operator==]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t.operator_eq__eq_..operator==..execution::blocking_adaptation_t] 
+Compare property values for equality. 
+
+
+  friend constexpr bool operator==(
+      const blocking_adaptation_t & a,
+      const blocking_adaptation_t & b);
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking_adaptation.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::blocking_adaptation_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_adaptation_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef blocking_adaptation_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking_adaptation.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__blocking_adaptation_t__allowed_t execution::blocking_adaptation_t::allowed_t]
+
+
+A sub-property that indicates that automatic adaptation is allowed. 
+
+
+  struct allowed_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__blocking_adaptation_t__allowed_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t__allowed_t.allowed_t [*allowed_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__blocking_adaptation_t__allowed_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t__allowed_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The blocking_adaptation_t::allowed_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t__allowed_t.is_preferable [*is_preferable]]]
+    [The blocking_adaptation_t::allowed_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t__allowed_t.is_requirable [*is_requirable]]]
+    [The blocking_adaptation_t::allowed_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking_adaptation.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:allowed_t execution::blocking_adaptation_t::allowed_t::allowed_t]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t__allowed_t.allowed_t..allowed_t..execution::blocking_adaptation_t::allowed_t] 
+Default constructor. 
+
+
+  constexpr allowed_t();
+
+
+
+[endsect]
+
+
+
+[section:is_applicable_property_v execution::blocking_adaptation_t::allowed_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t__allowed_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_adaptation_t::allowed_t] 
+The [link asio.reference.execution__blocking_adaptation_t__allowed_t `execution::blocking_adaptation_t::allowed_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::blocking_adaptation_t::allowed_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t__allowed_t.is_preferable..is_preferable..execution::blocking_adaptation_t::allowed_t] 
+The [link asio.reference.execution__blocking_adaptation_t__allowed_t `execution::blocking_adaptation_t::allowed_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::blocking_adaptation_t::allowed_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t__allowed_t.is_requirable..is_requirable..execution::blocking_adaptation_t::allowed_t] 
+The [link asio.reference.execution__blocking_adaptation_t__allowed_t `execution::blocking_adaptation_t::allowed_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::blocking_adaptation_t::allowed_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t__allowed_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_adaptation_t::allowed_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef blocking_adaptation_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking_adaptation.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:value execution::blocking_adaptation_t::allowed_t::value]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t__allowed_t.value..value..execution::blocking_adaptation_t::allowed_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr blocking_adaptation_t value();
+
+
+
+[heading Return Value]
+      
+`allowed_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__blocking_adaptation_t__disallowed_t execution::blocking_adaptation_t::disallowed_t]
+
+
+A sub-property that indicates that automatic adaptation is not allowed. 
+
+
+  struct disallowed_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t.disallowed_t [*disallowed_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The blocking_adaptation_t::disallowed_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t.is_preferable [*is_preferable]]]
+    [The blocking_adaptation_t::disallowed_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t.is_requirable [*is_requirable]]]
+    [The blocking_adaptation_t::disallowed_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking_adaptation.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:disallowed_t execution::blocking_adaptation_t::disallowed_t::disallowed_t]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t__disallowed_t.disallowed_t..disallowed_t..execution::blocking_adaptation_t::disallowed_t] 
+Default constructor. 
+
+
+  constexpr disallowed_t();
+
+
+
+[endsect]
+
+
+
+[section:is_applicable_property_v execution::blocking_adaptation_t::disallowed_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t__disallowed_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_adaptation_t::disallowed_t] 
+The [link asio.reference.execution__blocking_adaptation_t__disallowed_t `execution::blocking_adaptation_t::disallowed_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::blocking_adaptation_t::disallowed_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t__disallowed_t.is_preferable..is_preferable..execution::blocking_adaptation_t::disallowed_t] 
+The [link asio.reference.execution__blocking_adaptation_t__disallowed_t `execution::blocking_adaptation_t::disallowed_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::blocking_adaptation_t::disallowed_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t__disallowed_t.is_requirable..is_requirable..execution::blocking_adaptation_t::disallowed_t] 
+The [link asio.reference.execution__blocking_adaptation_t__disallowed_t `execution::blocking_adaptation_t::disallowed_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::blocking_adaptation_t::disallowed_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t__disallowed_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_adaptation_t::disallowed_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef blocking_adaptation_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking_adaptation.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:value execution::blocking_adaptation_t::disallowed_t::value]
+
+[indexterm2 asio.indexterm.execution__blocking_adaptation_t__disallowed_t.value..value..execution::blocking_adaptation_t::disallowed_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr blocking_adaptation_t value();
+
+
+
+[heading Return Value]
+      
+`disallowed_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__blocking_t execution::blocking_t]
+
+
+A property to describe what guarantees an executor makes about the blocking behaviour of their execution functions. 
+
+
+  struct blocking_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__blocking_t__always_t [*always_t]]]
+    [A sub-property that indicates that invocation of an executor's execution function shall block until completion of all invocations of the submitted function object. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__blocking_t__never_t [*never_t]]]
+    [A sub-property that indicates that invocation of an executor's execution function shall not block pending completion of the invocations of the submitted function object. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__blocking_t__possibly_t [*possibly_t]]]
+    [A sub-property that indicates that invocation of an executor's execution function may block pending completion of one or more invocations of the submitted function object. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__blocking_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_t.blocking_t [*blocking_t]]]
+    [Default constructor. 
+     [hr]
+     Construct from a sub-property value. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_t.always [*always]]]
+    [A special value used for accessing the blocking_t::always_t property. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The blocking_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_t.is_preferable [*is_preferable]]]
+    [The top-level blocking_t property cannot be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_t.is_requirable [*is_requirable]]]
+    [The top-level blocking_t property cannot be required. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_t.never [*never]]]
+    [A special value used for accessing the blocking_t::never_t property. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_t.possibly [*possibly]]]
+    [A special value used for accessing the blocking_t::possibly_t property. ]
+  ]
+
+]
+
+[heading Friends]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_t.operator_not__eq_ [*operator!=]]]
+    [Compare property values for inequality. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__blocking_t.operator_eq__eq_ [*operator==]]]
+    [Compare property values for equality. ]
+  ]
+  
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:always execution::blocking_t::always]
+
+[indexterm2 asio.indexterm.execution__blocking_t.always..always..execution::blocking_t] 
+A special value used for accessing the [link asio.reference.execution__blocking_t__always_t `execution::blocking_t::always_t`] property. 
+
+
+  static constexpr always_t always;
+
+
+
+[endsect]
+
+
+[section:blocking_t execution::blocking_t::blocking_t]
+
+[indexterm2 asio.indexterm.execution__blocking_t.blocking_t..blocking_t..execution::blocking_t] 
+Default constructor. 
+
+
+  constexpr ``[link asio.reference.execution__blocking_t.blocking_t.overload1 blocking_t]``();
+  ``  [''''&raquo;''' [link asio.reference.execution__blocking_t.blocking_t.overload1 more...]]``
+
+
+Construct from a sub-property value. 
+
+
+  constexpr ``[link asio.reference.execution__blocking_t.blocking_t.overload2 blocking_t]``(
+      possibly_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__blocking_t.blocking_t.overload2 more...]]``
+
+  constexpr ``[link asio.reference.execution__blocking_t.blocking_t.overload3 blocking_t]``(
+      always_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__blocking_t.blocking_t.overload3 more...]]``
+
+  constexpr ``[link asio.reference.execution__blocking_t.blocking_t.overload4 blocking_t]``(
+      never_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__blocking_t.blocking_t.overload4 more...]]``
+
+
+[section:overload1 execution::blocking_t::blocking_t (1 of 4 overloads)]
+
+
+Default constructor. 
+
+
+  constexpr blocking_t();
+
+
+
+[endsect]
+
+
+
+[section:overload2 execution::blocking_t::blocking_t (2 of 4 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr blocking_t(
+      possibly_t );
+
+
+
+[endsect]
+
+
+
+[section:overload3 execution::blocking_t::blocking_t (3 of 4 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr blocking_t(
+      always_t );
+
+
+
+[endsect]
+
+
+
+[section:overload4 execution::blocking_t::blocking_t (4 of 4 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr blocking_t(
+      never_t );
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:is_applicable_property_v execution::blocking_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__blocking_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_t] 
+The [link asio.reference.execution__blocking_t `execution::blocking_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::blocking_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__blocking_t.is_preferable..is_preferable..execution::blocking_t] 
+The top-level [link asio.reference.execution__blocking_t `execution::blocking_t`] property cannot be preferred. 
+
+
+  static constexpr bool is_preferable = false;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::blocking_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__blocking_t.is_requirable..is_requirable..execution::blocking_t] 
+The top-level [link asio.reference.execution__blocking_t `execution::blocking_t`] property cannot be required. 
+
+
+  static constexpr bool is_requirable = false;
+
+
+
+[endsect]
+
+
+
+[section:never execution::blocking_t::never]
+
+[indexterm2 asio.indexterm.execution__blocking_t.never..never..execution::blocking_t] 
+A special value used for accessing the [link asio.reference.execution__blocking_t__never_t `execution::blocking_t::never_t`] property. 
+
+
+  static constexpr never_t never;
+
+
+
+[endsect]
+
+
+
+[section:operator_not__eq_ execution::blocking_t::operator!=]
+
+[indexterm2 asio.indexterm.execution__blocking_t.operator_not__eq_..operator!=..execution::blocking_t] 
+Compare property values for inequality. 
+
+
+  friend constexpr bool operator!=(
+      const blocking_t & a,
+      const blocking_t & b);
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:operator_eq__eq_ execution::blocking_t::operator==]
+
+[indexterm2 asio.indexterm.execution__blocking_t.operator_eq__eq_..operator==..execution::blocking_t] 
+Compare property values for equality. 
+
+
+  friend constexpr bool operator==(
+      const blocking_t & a,
+      const blocking_t & b);
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::blocking_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__blocking_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef blocking_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:possibly execution::blocking_t::possibly]
+
+[indexterm2 asio.indexterm.execution__blocking_t.possibly..possibly..execution::blocking_t] 
+A special value used for accessing the [link asio.reference.execution__blocking_t__possibly_t `execution::blocking_t::possibly_t`] property. 
+
+
+  static constexpr possibly_t possibly;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__blocking_t__always_t execution::blocking_t::always_t]
+
+
+A sub-property that indicates that invocation of an executor's execution function shall block until completion of all invocations of the submitted function object. 
+
+
+  struct always_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__blocking_t__always_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_t__always_t.always_t [*always_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__blocking_t__always_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_t__always_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The blocking_t::always_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_t__always_t.is_preferable [*is_preferable]]]
+    [The blocking_t::always_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_t__always_t.is_requirable [*is_requirable]]]
+    [The blocking_t::always_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:always_t execution::blocking_t::always_t::always_t]
+
+[indexterm2 asio.indexterm.execution__blocking_t__always_t.always_t..always_t..execution::blocking_t::always_t] 
+Default constructor. 
+
+
+  constexpr always_t();
+
+
+
+[endsect]
+
+
+
+[section:is_applicable_property_v execution::blocking_t::always_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__blocking_t__always_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_t::always_t] 
+The [link asio.reference.execution__blocking_t__always_t `execution::blocking_t::always_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::blocking_t::always_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__blocking_t__always_t.is_preferable..is_preferable..execution::blocking_t::always_t] 
+The [link asio.reference.execution__blocking_t__always_t `execution::blocking_t::always_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::blocking_t::always_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__blocking_t__always_t.is_requirable..is_requirable..execution::blocking_t::always_t] 
+The [link asio.reference.execution__blocking_t__always_t `execution::blocking_t::always_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::blocking_t::always_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__blocking_t__always_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_t::always_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef blocking_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:value execution::blocking_t::always_t::value]
+
+[indexterm2 asio.indexterm.execution__blocking_t__always_t.value..value..execution::blocking_t::always_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr blocking_t value();
+
+
+
+[heading Return Value]
+      
+`always_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__blocking_t__never_t execution::blocking_t::never_t]
+
+
+A sub-property that indicates that invocation of an executor's execution function shall not block pending completion of the invocations of the submitted function object. 
+
+
+  struct never_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__blocking_t__never_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_t__never_t.never_t [*never_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__blocking_t__never_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_t__never_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The blocking_t::never_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_t__never_t.is_preferable [*is_preferable]]]
+    [The blocking_t::never_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_t__never_t.is_requirable [*is_requirable]]]
+    [The blocking_t::never_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::blocking_t::never_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__blocking_t__never_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_t::never_t] 
+The [link asio.reference.execution__blocking_t__never_t `execution::blocking_t::never_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::blocking_t::never_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__blocking_t__never_t.is_preferable..is_preferable..execution::blocking_t::never_t] 
+The [link asio.reference.execution__blocking_t__never_t `execution::blocking_t::never_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::blocking_t::never_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__blocking_t__never_t.is_requirable..is_requirable..execution::blocking_t::never_t] 
+The [link asio.reference.execution__blocking_t__never_t `execution::blocking_t::never_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:never_t execution::blocking_t::never_t::never_t]
+
+[indexterm2 asio.indexterm.execution__blocking_t__never_t.never_t..never_t..execution::blocking_t::never_t] 
+Default constructor. 
+
+
+  constexpr never_t();
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::blocking_t::never_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__blocking_t__never_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_t::never_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef blocking_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:value execution::blocking_t::never_t::value]
+
+[indexterm2 asio.indexterm.execution__blocking_t__never_t.value..value..execution::blocking_t::never_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr blocking_t value();
+
+
+
+[heading Return Value]
+      
+`never_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__blocking_t__possibly_t execution::blocking_t::possibly_t]
+
+
+A sub-property that indicates that invocation of an executor's execution function may block pending completion of one or more invocations of the submitted function object. 
+
+
+  struct possibly_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__blocking_t__possibly_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_t__possibly_t.possibly_t [*possibly_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__blocking_t__possibly_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__blocking_t__possibly_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The blocking_t::possibly_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_t__possibly_t.is_preferable [*is_preferable]]]
+    [The blocking_t::possibly_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__blocking_t__possibly_t.is_requirable [*is_requirable]]]
+    [The blocking_t::possibly_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::blocking_t::possibly_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__blocking_t__possibly_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_t::possibly_t] 
+The [link asio.reference.execution__blocking_t__possibly_t `execution::blocking_t::possibly_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::blocking_t::possibly_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__blocking_t__possibly_t.is_preferable..is_preferable..execution::blocking_t::possibly_t] 
+The [link asio.reference.execution__blocking_t__possibly_t `execution::blocking_t::possibly_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::blocking_t::possibly_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__blocking_t__possibly_t.is_requirable..is_requirable..execution::blocking_t::possibly_t] 
+The [link asio.reference.execution__blocking_t__possibly_t `execution::blocking_t::possibly_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::blocking_t::possibly_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__blocking_t__possibly_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_t::possibly_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef blocking_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/blocking.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:possibly_t execution::blocking_t::possibly_t::possibly_t]
+
+[indexterm2 asio.indexterm.execution__blocking_t__possibly_t.possibly_t..possibly_t..execution::blocking_t::possibly_t] 
+Default constructor. 
+
+
+  constexpr possibly_t();
+
+
+
+[endsect]
+
+
+
+[section:value execution::blocking_t::possibly_t::value]
+
+[indexterm2 asio.indexterm.execution__blocking_t__possibly_t.value..value..execution::blocking_t::possibly_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr blocking_t value();
+
+
+
+[heading Return Value]
+      
+`possibly_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:execution__bulk_guarantee execution::bulk_guarantee]
+
+[indexterm1 asio.indexterm.execution__bulk_guarantee..execution::bulk_guarantee] 
+A special value used for accessing the [link asio.reference.execution__bulk_guarantee_t `execution::bulk_guarantee_t`] property. 
+
+
+  constexpr bulk_guarantee_t bulk_guarantee;
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/bulk_guarantee.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+[section:execution__bulk_guarantee_t execution::bulk_guarantee_t]
+
+
+A property to communicate the forward progress and ordering guarantees of execution agents associated with the bulk execution. 
+
+
+  struct bulk_guarantee_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__bulk_guarantee_t__parallel_t [*parallel_t]]]
+    [A sub-property that indicates that execution agents within the same bulk execution may be parallelised. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__bulk_guarantee_t__sequenced_t [*sequenced_t]]]
+    [A sub-property that indicates that execution agents within the same bulk execution may not be parallelised and vectorised. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__bulk_guarantee_t__unsequenced_t [*unsequenced_t]]]
+    [A sub-property that indicates that execution agents within the same bulk execution may be parallelised and vectorised. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__bulk_guarantee_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t.bulk_guarantee_t [*bulk_guarantee_t]]]
+    [Default constructor. 
+     [hr]
+     Construct from a sub-property value. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The bulk_guarantee_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t.is_preferable [*is_preferable]]]
+    [The top-level bulk_guarantee_t property cannot be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t.is_requirable [*is_requirable]]]
+    [The top-level bulk_guarantee_t property cannot be required. ]
+  ]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t.parallel [*parallel]]]
+    [A special value used for accessing the bulk_guarantee_t::parallel_t property. ]
+  ]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t.sequenced [*sequenced]]]
+    [A special value used for accessing the bulk_guarantee_t::sequenced_t property. ]
+  ]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t.unsequenced [*unsequenced]]]
+    [A special value used for accessing the bulk_guarantee_t::unsequenced_t property. ]
+  ]
+
+]
+
+[heading Friends]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t.operator_not__eq_ [*operator!=]]]
+    [Compare property values for inequality. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__bulk_guarantee_t.operator_eq__eq_ [*operator==]]]
+    [Compare property values for equality. ]
+  ]
+  
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/bulk_guarantee.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+[section:bulk_guarantee_t execution::bulk_guarantee_t::bulk_guarantee_t]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t.bulk_guarantee_t..bulk_guarantee_t..execution::bulk_guarantee_t] 
+Default constructor. 
+
+
+  constexpr ``[link asio.reference.execution__bulk_guarantee_t.bulk_guarantee_t.overload1 bulk_guarantee_t]``();
+  ``  [''''&raquo;''' [link asio.reference.execution__bulk_guarantee_t.bulk_guarantee_t.overload1 more...]]``
+
+
+Construct from a sub-property value. 
+
+
+  constexpr ``[link asio.reference.execution__bulk_guarantee_t.bulk_guarantee_t.overload2 bulk_guarantee_t]``(
+      unsequenced_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__bulk_guarantee_t.bulk_guarantee_t.overload2 more...]]``
+
+  constexpr ``[link asio.reference.execution__bulk_guarantee_t.bulk_guarantee_t.overload3 bulk_guarantee_t]``(
+      sequenced_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__bulk_guarantee_t.bulk_guarantee_t.overload3 more...]]``
+
+  constexpr ``[link asio.reference.execution__bulk_guarantee_t.bulk_guarantee_t.overload4 bulk_guarantee_t]``(
+      parallel_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__bulk_guarantee_t.bulk_guarantee_t.overload4 more...]]``
+
+
+[section:overload1 execution::bulk_guarantee_t::bulk_guarantee_t (1 of 4 overloads)]
+
+
+Default constructor. 
+
+
+  constexpr bulk_guarantee_t();
+
+
+
+[endsect]
+
+
+
+[section:overload2 execution::bulk_guarantee_t::bulk_guarantee_t (2 of 4 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr bulk_guarantee_t(
+      unsequenced_t );
+
+
+
+[endsect]
+
+
+
+[section:overload3 execution::bulk_guarantee_t::bulk_guarantee_t (3 of 4 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr bulk_guarantee_t(
+      sequenced_t );
+
+
+
+[endsect]
+
+
+
+[section:overload4 execution::bulk_guarantee_t::bulk_guarantee_t (4 of 4 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr bulk_guarantee_t(
+      parallel_t );
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:is_applicable_property_v execution::bulk_guarantee_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t.is_applicable_property_v..is_applicable_property_v..execution::bulk_guarantee_t] 
+The [link asio.reference.execution__bulk_guarantee_t `execution::bulk_guarantee_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::bulk_guarantee_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t.is_preferable..is_preferable..execution::bulk_guarantee_t] 
+The top-level [link asio.reference.execution__bulk_guarantee_t `execution::bulk_guarantee_t`] property cannot be preferred. 
+
+
+  static constexpr bool is_preferable = false;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::bulk_guarantee_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t.is_requirable..is_requirable..execution::bulk_guarantee_t] 
+The top-level [link asio.reference.execution__bulk_guarantee_t `execution::bulk_guarantee_t`] property cannot be required. 
+
+
+  static constexpr bool is_requirable = false;
+
+
+
+[endsect]
+
+
+
+[section:operator_not__eq_ execution::bulk_guarantee_t::operator!=]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t.operator_not__eq_..operator!=..execution::bulk_guarantee_t] 
+Compare property values for inequality. 
+
+
+  friend constexpr bool operator!=(
+      const bulk_guarantee_t & a,
+      const bulk_guarantee_t & b);
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/bulk_guarantee.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:operator_eq__eq_ execution::bulk_guarantee_t::operator==]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t.operator_eq__eq_..operator==..execution::bulk_guarantee_t] 
+Compare property values for equality. 
+
+
+  friend constexpr bool operator==(
+      const bulk_guarantee_t & a,
+      const bulk_guarantee_t & b);
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/bulk_guarantee.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:parallel execution::bulk_guarantee_t::parallel]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t.parallel..parallel..execution::bulk_guarantee_t] 
+A special value used for accessing the [link asio.reference.execution__bulk_guarantee_t__parallel_t `execution::bulk_guarantee_t::parallel_t`] property. 
+
+
+  static constexpr parallel_t parallel;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::bulk_guarantee_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::bulk_guarantee_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef bulk_guarantee_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/bulk_guarantee.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:sequenced execution::bulk_guarantee_t::sequenced]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t.sequenced..sequenced..execution::bulk_guarantee_t] 
+A special value used for accessing the [link asio.reference.execution__bulk_guarantee_t__sequenced_t `execution::bulk_guarantee_t::sequenced_t`] property. 
+
+
+  static constexpr sequenced_t sequenced;
+
+
+
+[endsect]
+
+
+
+[section:unsequenced execution::bulk_guarantee_t::unsequenced]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t.unsequenced..unsequenced..execution::bulk_guarantee_t] 
+A special value used for accessing the [link asio.reference.execution__bulk_guarantee_t__unsequenced_t `execution::bulk_guarantee_t::unsequenced_t`] property. 
+
+
+  static constexpr unsequenced_t unsequenced;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__bulk_guarantee_t__parallel_t execution::bulk_guarantee_t::parallel_t]
+
+
+A sub-property that indicates that execution agents within the same bulk execution may be parallelised. 
+
+
+  struct parallel_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__bulk_guarantee_t__parallel_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__parallel_t.parallel_t [*parallel_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__parallel_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__parallel_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The bulk_guarantee_t::parallel_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__parallel_t.is_preferable [*is_preferable]]]
+    [The bulk_guarantee_t::parallel_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__parallel_t.is_requirable [*is_requirable]]]
+    [The bulk_guarantee_t::parallel_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/bulk_guarantee.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::bulk_guarantee_t::parallel_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__parallel_t.is_applicable_property_v..is_applicable_property_v..execution::bulk_guarantee_t::parallel_t] 
+The [link asio.reference.execution__bulk_guarantee_t__parallel_t `execution::bulk_guarantee_t::parallel_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::bulk_guarantee_t::parallel_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__parallel_t.is_preferable..is_preferable..execution::bulk_guarantee_t::parallel_t] 
+The [link asio.reference.execution__bulk_guarantee_t__parallel_t `execution::bulk_guarantee_t::parallel_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::bulk_guarantee_t::parallel_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__parallel_t.is_requirable..is_requirable..execution::bulk_guarantee_t::parallel_t] 
+The [link asio.reference.execution__bulk_guarantee_t__parallel_t `execution::bulk_guarantee_t::parallel_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:parallel_t execution::bulk_guarantee_t::parallel_t::parallel_t]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__parallel_t.parallel_t..parallel_t..execution::bulk_guarantee_t::parallel_t] 
+Default constructor. 
+
+
+  constexpr parallel_t();
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::bulk_guarantee_t::parallel_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__parallel_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::bulk_guarantee_t::parallel_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef bulk_guarantee_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/bulk_guarantee.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:value execution::bulk_guarantee_t::parallel_t::value]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__parallel_t.value..value..execution::bulk_guarantee_t::parallel_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr bulk_guarantee_t value();
+
+
+
+[heading Return Value]
+      
+`parallel_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__bulk_guarantee_t__sequenced_t execution::bulk_guarantee_t::sequenced_t]
+
+
+A sub-property that indicates that execution agents within the same bulk execution may not be parallelised and vectorised. 
+
+
+  struct sequenced_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__bulk_guarantee_t__sequenced_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__sequenced_t.sequenced_t [*sequenced_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__sequenced_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__sequenced_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The bulk_guarantee_t::sequenced_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__sequenced_t.is_preferable [*is_preferable]]]
+    [The bulk_guarantee_t::sequenced_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__sequenced_t.is_requirable [*is_requirable]]]
+    [The bulk_guarantee_t::sequenced_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/bulk_guarantee.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::bulk_guarantee_t::sequenced_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__sequenced_t.is_applicable_property_v..is_applicable_property_v..execution::bulk_guarantee_t::sequenced_t] 
+The [link asio.reference.execution__bulk_guarantee_t__sequenced_t `execution::bulk_guarantee_t::sequenced_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::bulk_guarantee_t::sequenced_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__sequenced_t.is_preferable..is_preferable..execution::bulk_guarantee_t::sequenced_t] 
+The [link asio.reference.execution__bulk_guarantee_t__sequenced_t `execution::bulk_guarantee_t::sequenced_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::bulk_guarantee_t::sequenced_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__sequenced_t.is_requirable..is_requirable..execution::bulk_guarantee_t::sequenced_t] 
+The [link asio.reference.execution__bulk_guarantee_t__sequenced_t `execution::bulk_guarantee_t::sequenced_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::bulk_guarantee_t::sequenced_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__sequenced_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::bulk_guarantee_t::sequenced_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef bulk_guarantee_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/bulk_guarantee.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:sequenced_t execution::bulk_guarantee_t::sequenced_t::sequenced_t]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__sequenced_t.sequenced_t..sequenced_t..execution::bulk_guarantee_t::sequenced_t] 
+Default constructor. 
+
+
+  constexpr sequenced_t();
+
+
+
+[endsect]
+
+
+
+[section:value execution::bulk_guarantee_t::sequenced_t::value]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__sequenced_t.value..value..execution::bulk_guarantee_t::sequenced_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr bulk_guarantee_t value();
+
+
+
+[heading Return Value]
+      
+`sequenced_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__bulk_guarantee_t__unsequenced_t execution::bulk_guarantee_t::unsequenced_t]
+
+
+A sub-property that indicates that execution agents within the same bulk execution may be parallelised and vectorised. 
+
+
+  struct unsequenced_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__bulk_guarantee_t__unsequenced_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__unsequenced_t.unsequenced_t [*unsequenced_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__unsequenced_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__unsequenced_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The bulk_guarantee_t::unsequenced_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__unsequenced_t.is_preferable [*is_preferable]]]
+    [The bulk_guarantee_t::unsequenced_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__bulk_guarantee_t__unsequenced_t.is_requirable [*is_requirable]]]
+    [The bulk_guarantee_t::unsequenced_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/bulk_guarantee.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::bulk_guarantee_t::unsequenced_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__unsequenced_t.is_applicable_property_v..is_applicable_property_v..execution::bulk_guarantee_t::unsequenced_t] 
+The [link asio.reference.execution__bulk_guarantee_t__unsequenced_t `execution::bulk_guarantee_t::unsequenced_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::bulk_guarantee_t::unsequenced_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__unsequenced_t.is_preferable..is_preferable..execution::bulk_guarantee_t::unsequenced_t] 
+The [link asio.reference.execution__bulk_guarantee_t__unsequenced_t `execution::bulk_guarantee_t::unsequenced_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::bulk_guarantee_t::unsequenced_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__unsequenced_t.is_requirable..is_requirable..execution::bulk_guarantee_t::unsequenced_t] 
+The [link asio.reference.execution__bulk_guarantee_t__unsequenced_t `execution::bulk_guarantee_t::unsequenced_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::bulk_guarantee_t::unsequenced_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__unsequenced_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::bulk_guarantee_t::unsequenced_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef bulk_guarantee_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/bulk_guarantee.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:unsequenced_t execution::bulk_guarantee_t::unsequenced_t::unsequenced_t]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__unsequenced_t.unsequenced_t..unsequenced_t..execution::bulk_guarantee_t::unsequenced_t] 
+Default constructor. 
+
+
+  constexpr unsequenced_t();
+
+
+
+[endsect]
+
+
+
+[section:value execution::bulk_guarantee_t::unsequenced_t::value]
+
+[indexterm2 asio.indexterm.execution__bulk_guarantee_t__unsequenced_t.value..value..execution::bulk_guarantee_t::unsequenced_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr bulk_guarantee_t value();
+
+
+
+[heading Return Value]
+      
+`unsequenced_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__can_execute execution::can_execute]
+
+
+A type trait that determines whether a `execute` expression is well-formed. 
+
+
+  template<
+      typename T,
+      typename F>
+  struct can_execute
+
+
+Class template `can_execute` is a trait that is derived from `true_type` if the expression `execution::execute(std::declval<T>(), std::declval<F>())` is well formed; otherwise `false_type`. 
+
+[heading Requirements]
+
+['Header: ][^asio/execution/execute.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+[section:execution__context execution::context]
+
+[indexterm1 asio.indexterm.execution__context..execution::context] 
+A special value used for accessing the [link asio.reference.execution__context_t `execution::context_t`] property. 
+
+
+  constexpr context_t context;
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/context.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:execution__context_as execution::context_as]
+
+[indexterm1 asio.indexterm.execution__context_as..execution::context_as] 
+A special value used for accessing the [link asio.reference.execution__context_as_t `execution::context_as_t`] property. 
+
+
+  template <typename U>
+  constexpr context_as_t context_as;
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/context_as.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+[section:execution__context_as_t execution::context_as_t]
+
+
+A property that is used to obtain the execution context that is associated with an executor. 
+
+
+  template<
+      typename U>
+  struct context_as_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__context_as_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__context_as_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The context_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__context_as_t.is_preferable [*is_preferable]]]
+    [The context_t property cannot be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__context_as_t.is_requirable [*is_requirable]]]
+    [The context_t property cannot be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/context_as.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::context_as_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__context_as_t.is_applicable_property_v..is_applicable_property_v..execution::context_as_t] 
+The [link asio.reference.execution__context_t `execution::context_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::context_as_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__context_as_t.is_preferable..is_preferable..execution::context_as_t] 
+The [link asio.reference.execution__context_t `execution::context_t`] property cannot be preferred. 
+
+
+  static constexpr bool is_preferable = false;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::context_as_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__context_as_t.is_requirable..is_requirable..execution::context_as_t] 
+The [link asio.reference.execution__context_t `execution::context_t`] property cannot be required. 
+
+
+  static constexpr bool is_requirable = false;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::context_as_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__context_as_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::context_as_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef T polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/context_as.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__context_t execution::context_t]
+
+
+A property that is used to obtain the execution context that is associated with an executor. 
+
+
+  struct context_t
+
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__context_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The context_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__context_t.is_preferable [*is_preferable]]]
+    [The context_t property cannot be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__context_t.is_requirable [*is_requirable]]]
+    [The context_t property cannot be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/context.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::context_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__context_t.is_applicable_property_v..is_applicable_property_v..execution::context_t] 
+The [link asio.reference.execution__context_t `execution::context_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::context_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__context_t.is_preferable..is_preferable..execution::context_t] 
+The [link asio.reference.execution__context_t `execution::context_t`] property cannot be preferred. 
+
+
+  static constexpr bool is_preferable = false;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::context_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__context_t.is_requirable..is_requirable..execution::context_t] 
+The [link asio.reference.execution__context_t `execution::context_t`] property cannot be required. 
+
+
+  static constexpr bool is_requirable = false;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:execution__execute execution::execute]
+
+[indexterm1 asio.indexterm.execution__execute..execution::execute] 
+A customisation point that executes a function on an executor. 
+
+
+  constexpr unspecified execute = unspecified;
+
+
+The name `execution::execute` denotes a customization point object.
+
+For some subexpressions `e` and `f`, let `E` be a type such that `decltype((e))` is `E` and let `F` be a type such that `decltype((f))` is `F`. The expression `execution::execute(e, f)` is ill-formed if `F` does not model `invocable`, or if `E` does not model either `executor` or `sender`. Otherwise, it is expression-equivalent to:
+
+
+* `e.execute(f)`, if that expression is valid. If the function selected does not execute the function object `f` on the executor `e`, the program is ill-formed with no diagnostic required.
+
+
+* Otherwise, `execute(e, f)`, if that expression is valid, with overload resolution performed in a context that includes the declaration `void execute();` and that does not include a declaration of `execution::execute`. If the function selected by overload resolution does not execute the function object `f` on the executor `e`, the program is ill-formed with no diagnostic required. 
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/execute.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+[section:execution__invocable_archetype execution::invocable_archetype]
+
+
+An archetypal function object used for determining adherence to the execution::executor concept. 
+
+
+  struct invocable_archetype
+
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__invocable_archetype.operator_lp__rp_ [*operator()]]]
+    [Function call operator. ]
+  ]
+  
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/invocable_archetype.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:operator_lp__rp_ execution::invocable_archetype::operator()]
+
+[indexterm2 asio.indexterm.execution__invocable_archetype.operator_lp__rp_..operator()..execution::invocable_archetype] 
+Function call operator. 
+
+
+  template<
+      typename... Args>
+  void operator()(
+      Args && ...);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__is_executor execution::is_executor]
+
+
+The [link asio.reference.execution__is_executor `execution::is_executor`] trait detects whether a type T satisfies the execution::executor concept. 
+
+
+  template<
+      typename T>
+  struct is_executor
+
+
+Class template `is_executor` is a UnaryTypeTrait that is derived from `true_type` if the type `T` meets the concept definition for an executor, otherwise `false_type`. 
+
+[heading Requirements]
+
+['Header: ][^asio/execution/executor.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+[section:execution__mapping execution::mapping]
+
+[indexterm1 asio.indexterm.execution__mapping..execution::mapping] 
+A special value used for accessing the [link asio.reference.execution__mapping_t `execution::mapping_t`] property. 
+
+
+  constexpr mapping_t mapping;
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/mapping.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+[section:execution__mapping_t execution::mapping_t]
+
+
+A property to describe what guarantees an executor makes about the mapping of execution agents on to threads of execution. 
+
+
+  struct mapping_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__mapping_t__new_thread_t [*new_thread_t]]]
+    [A sub-property that indicates that execution agents are mapped on to new threads of execution. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__mapping_t__other_t [*other_t]]]
+    [A sub-property that indicates that the mapping of execution agents is implementation-defined. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__mapping_t__thread_t [*thread_t]]]
+    [A sub-property that indicates that execution agents are mapped on to threads of execution. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__mapping_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__mapping_t.mapping_t [*mapping_t]]]
+    [Default constructor. 
+     [hr]
+     Construct from a sub-property value. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__mapping_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The mapping_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__mapping_t.is_preferable [*is_preferable]]]
+    [The top-level mapping_t property cannot be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__mapping_t.is_requirable [*is_requirable]]]
+    [The top-level mapping_t property cannot be required. ]
+  ]
+
+  [
+    [[link asio.reference.execution__mapping_t.new_thread [*new_thread]]]
+    [A special value used for accessing the mapping_t::new_thread_t property. ]
+  ]
+
+  [
+    [[link asio.reference.execution__mapping_t.other [*other]]]
+    [A special value used for accessing the mapping_t::other_t property. ]
+  ]
+
+  [
+    [[link asio.reference.execution__mapping_t.thread [*thread]]]
+    [A special value used for accessing the mapping_t::thread_t property. ]
+  ]
+
+]
+
+[heading Friends]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__mapping_t.operator_not__eq_ [*operator!=]]]
+    [Compare property values for inequality. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__mapping_t.operator_eq__eq_ [*operator==]]]
+    [Compare property values for equality. ]
+  ]
+  
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/mapping.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::mapping_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__mapping_t.is_applicable_property_v..is_applicable_property_v..execution::mapping_t] 
+The [link asio.reference.execution__mapping_t `execution::mapping_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::mapping_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__mapping_t.is_preferable..is_preferable..execution::mapping_t] 
+The top-level [link asio.reference.execution__mapping_t `execution::mapping_t`] property cannot be preferred. 
+
+
+  static constexpr bool is_preferable = false;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::mapping_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__mapping_t.is_requirable..is_requirable..execution::mapping_t] 
+The top-level [link asio.reference.execution__mapping_t `execution::mapping_t`] property cannot be required. 
+
+
+  static constexpr bool is_requirable = false;
+
+
+
+[endsect]
+
+
+[section:mapping_t execution::mapping_t::mapping_t]
+
+[indexterm2 asio.indexterm.execution__mapping_t.mapping_t..mapping_t..execution::mapping_t] 
+Default constructor. 
+
+
+  constexpr ``[link asio.reference.execution__mapping_t.mapping_t.overload1 mapping_t]``();
+  ``  [''''&raquo;''' [link asio.reference.execution__mapping_t.mapping_t.overload1 more...]]``
+
+
+Construct from a sub-property value. 
+
+
+  constexpr ``[link asio.reference.execution__mapping_t.mapping_t.overload2 mapping_t]``(
+      thread_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__mapping_t.mapping_t.overload2 more...]]``
+
+  constexpr ``[link asio.reference.execution__mapping_t.mapping_t.overload3 mapping_t]``(
+      new_thread_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__mapping_t.mapping_t.overload3 more...]]``
+
+  constexpr ``[link asio.reference.execution__mapping_t.mapping_t.overload4 mapping_t]``(
+      other_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__mapping_t.mapping_t.overload4 more...]]``
+
+
+[section:overload1 execution::mapping_t::mapping_t (1 of 4 overloads)]
+
+
+Default constructor. 
+
+
+  constexpr mapping_t();
+
+
+
+[endsect]
+
+
+
+[section:overload2 execution::mapping_t::mapping_t (2 of 4 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr mapping_t(
+      thread_t );
+
+
+
+[endsect]
+
+
+
+[section:overload3 execution::mapping_t::mapping_t (3 of 4 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr mapping_t(
+      new_thread_t );
+
+
+
+[endsect]
+
+
+
+[section:overload4 execution::mapping_t::mapping_t (4 of 4 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr mapping_t(
+      other_t );
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:new_thread execution::mapping_t::new_thread]
+
+[indexterm2 asio.indexterm.execution__mapping_t.new_thread..new_thread..execution::mapping_t] 
+A special value used for accessing the [link asio.reference.execution__mapping_t__new_thread_t `execution::mapping_t::new_thread_t`] property. 
+
+
+  static constexpr new_thread_t new_thread;
+
+
+
+[endsect]
+
+
+
+[section:operator_not__eq_ execution::mapping_t::operator!=]
+
+[indexterm2 asio.indexterm.execution__mapping_t.operator_not__eq_..operator!=..execution::mapping_t] 
+Compare property values for inequality. 
+
+
+  friend constexpr bool operator!=(
+      const mapping_t & a,
+      const mapping_t & b);
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/mapping.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:operator_eq__eq_ execution::mapping_t::operator==]
+
+[indexterm2 asio.indexterm.execution__mapping_t.operator_eq__eq_..operator==..execution::mapping_t] 
+Compare property values for equality. 
+
+
+  friend constexpr bool operator==(
+      const mapping_t & a,
+      const mapping_t & b);
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/mapping.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:other execution::mapping_t::other]
+
+[indexterm2 asio.indexterm.execution__mapping_t.other..other..execution::mapping_t] 
+A special value used for accessing the [link asio.reference.execution__mapping_t__other_t `execution::mapping_t::other_t`] property. 
+
+
+  static constexpr other_t other;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::mapping_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__mapping_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::mapping_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef mapping_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/mapping.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:thread execution::mapping_t::thread]
+
+[indexterm2 asio.indexterm.execution__mapping_t.thread..thread..execution::mapping_t] 
+A special value used for accessing the [link asio.reference.execution__mapping_t__thread_t `execution::mapping_t::thread_t`] property. 
+
+
+  static constexpr thread_t thread;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__mapping_t__new_thread_t execution::mapping_t::new_thread_t]
+
+
+A sub-property that indicates that execution agents are mapped on to new threads of execution. 
+
+
+  struct new_thread_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__mapping_t__new_thread_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__mapping_t__new_thread_t.new_thread_t [*new_thread_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__mapping_t__new_thread_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__mapping_t__new_thread_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The mapping_t::new_thread_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__mapping_t__new_thread_t.is_preferable [*is_preferable]]]
+    [The mapping_t::new_thread_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__mapping_t__new_thread_t.is_requirable [*is_requirable]]]
+    [The mapping_t::new_thread_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/mapping.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::mapping_t::new_thread_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__mapping_t__new_thread_t.is_applicable_property_v..is_applicable_property_v..execution::mapping_t::new_thread_t] 
+The [link asio.reference.execution__mapping_t__new_thread_t `execution::mapping_t::new_thread_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::mapping_t::new_thread_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__mapping_t__new_thread_t.is_preferable..is_preferable..execution::mapping_t::new_thread_t] 
+The [link asio.reference.execution__mapping_t__new_thread_t `execution::mapping_t::new_thread_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::mapping_t::new_thread_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__mapping_t__new_thread_t.is_requirable..is_requirable..execution::mapping_t::new_thread_t] 
+The [link asio.reference.execution__mapping_t__new_thread_t `execution::mapping_t::new_thread_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:new_thread_t execution::mapping_t::new_thread_t::new_thread_t]
+
+[indexterm2 asio.indexterm.execution__mapping_t__new_thread_t.new_thread_t..new_thread_t..execution::mapping_t::new_thread_t] 
+Default constructor. 
+
+
+  constexpr new_thread_t();
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::mapping_t::new_thread_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__mapping_t__new_thread_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::mapping_t::new_thread_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef mapping_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/mapping.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:value execution::mapping_t::new_thread_t::value]
+
+[indexterm2 asio.indexterm.execution__mapping_t__new_thread_t.value..value..execution::mapping_t::new_thread_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr mapping_t value();
+
+
+
+[heading Return Value]
+      
+`new_thread_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__mapping_t__other_t execution::mapping_t::other_t]
+
+
+A sub-property that indicates that the mapping of execution agents is implementation-defined. 
+
+
+  struct other_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__mapping_t__other_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__mapping_t__other_t.other_t [*other_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__mapping_t__other_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__mapping_t__other_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The mapping_t::other_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__mapping_t__other_t.is_preferable [*is_preferable]]]
+    [The mapping_t::other_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__mapping_t__other_t.is_requirable [*is_requirable]]]
+    [The mapping_t::other_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/mapping.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::mapping_t::other_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__mapping_t__other_t.is_applicable_property_v..is_applicable_property_v..execution::mapping_t::other_t] 
+The [link asio.reference.execution__mapping_t__other_t `execution::mapping_t::other_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::mapping_t::other_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__mapping_t__other_t.is_preferable..is_preferable..execution::mapping_t::other_t] 
+The [link asio.reference.execution__mapping_t__other_t `execution::mapping_t::other_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::mapping_t::other_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__mapping_t__other_t.is_requirable..is_requirable..execution::mapping_t::other_t] 
+The [link asio.reference.execution__mapping_t__other_t `execution::mapping_t::other_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:other_t execution::mapping_t::other_t::other_t]
+
+[indexterm2 asio.indexterm.execution__mapping_t__other_t.other_t..other_t..execution::mapping_t::other_t] 
+Default constructor. 
+
+
+  constexpr other_t();
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::mapping_t::other_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__mapping_t__other_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::mapping_t::other_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef mapping_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/mapping.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:value execution::mapping_t::other_t::value]
+
+[indexterm2 asio.indexterm.execution__mapping_t__other_t.value..value..execution::mapping_t::other_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr mapping_t value();
+
+
+
+[heading Return Value]
+      
+`other_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__mapping_t__thread_t execution::mapping_t::thread_t]
+
+
+A sub-property that indicates that execution agents are mapped on to threads of execution. 
+
+
+  struct thread_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__mapping_t__thread_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__mapping_t__thread_t.thread_t [*thread_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__mapping_t__thread_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__mapping_t__thread_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The mapping_t::thread_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__mapping_t__thread_t.is_preferable [*is_preferable]]]
+    [The mapping_t::thread_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__mapping_t__thread_t.is_requirable [*is_requirable]]]
+    [The mapping_t::thread_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/mapping.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::mapping_t::thread_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__mapping_t__thread_t.is_applicable_property_v..is_applicable_property_v..execution::mapping_t::thread_t] 
+The [link asio.reference.execution__mapping_t__thread_t `execution::mapping_t::thread_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::mapping_t::thread_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__mapping_t__thread_t.is_preferable..is_preferable..execution::mapping_t::thread_t] 
+The [link asio.reference.execution__mapping_t__thread_t `execution::mapping_t::thread_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::mapping_t::thread_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__mapping_t__thread_t.is_requirable..is_requirable..execution::mapping_t::thread_t] 
+The [link asio.reference.execution__mapping_t__thread_t `execution::mapping_t::thread_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::mapping_t::thread_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__mapping_t__thread_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::mapping_t::thread_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef mapping_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/mapping.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:thread_t execution::mapping_t::thread_t::thread_t]
+
+[indexterm2 asio.indexterm.execution__mapping_t__thread_t.thread_t..thread_t..execution::mapping_t::thread_t] 
+Default constructor. 
+
+
+  constexpr thread_t();
+
+
+
+[endsect]
+
+
+
+[section:value execution::mapping_t::thread_t::value]
+
+[indexterm2 asio.indexterm.execution__mapping_t__thread_t.value..value..execution::mapping_t::thread_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr mapping_t value();
+
+
+
+[heading Return Value]
+      
+`thread_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:execution__occupancy execution::occupancy]
+
+[indexterm1 asio.indexterm.execution__occupancy..execution::occupancy] 
+A special value used for accessing the [link asio.reference.execution__occupancy_t `execution::occupancy_t`] property. 
+
+
+  constexpr occupancy_t occupancy;
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/occupancy.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+[section:execution__occupancy_t execution::occupancy_t]
+
+
+A property that gives an estimate of the number of execution agents that should occupy the associated execution context. 
+
+
+  struct occupancy_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__occupancy_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__occupancy_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The occupancy_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__occupancy_t.is_preferable [*is_preferable]]]
+    [The occupancy_t property cannot be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__occupancy_t.is_requirable [*is_requirable]]]
+    [The occupancy_t property cannot be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/occupancy.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::occupancy_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__occupancy_t.is_applicable_property_v..is_applicable_property_v..execution::occupancy_t] 
+The [link asio.reference.execution__occupancy_t `execution::occupancy_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::occupancy_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__occupancy_t.is_preferable..is_preferable..execution::occupancy_t] 
+The [link asio.reference.execution__occupancy_t `execution::occupancy_t`] property cannot be preferred. 
+
+
+  static constexpr bool is_preferable = false;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::occupancy_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__occupancy_t.is_requirable..is_requirable..execution::occupancy_t] 
+The [link asio.reference.execution__occupancy_t `execution::occupancy_t`] property cannot be required. 
+
+
+  static constexpr bool is_requirable = false;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::occupancy_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__occupancy_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::occupancy_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef std::size_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/occupancy.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:execution__outstanding_work execution::outstanding_work]
+
+[indexterm1 asio.indexterm.execution__outstanding_work..execution::outstanding_work] 
+A special value used for accessing the [link asio.reference.execution__outstanding_work_t `execution::outstanding_work_t`] property. 
+
+
+  constexpr outstanding_work_t outstanding_work;
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/outstanding_work.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+[section:execution__outstanding_work_t execution::outstanding_work_t]
+
+
+A property to describe whether task submission is likely in the future. 
+
+
+  struct outstanding_work_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__outstanding_work_t__tracked_t [*tracked_t]]]
+    [A sub-property that indicates that the executor represents likely future submission of a function object. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__outstanding_work_t__untracked_t [*untracked_t]]]
+    [A sub-property that indicates that the executor does not represent likely future submission of a function object. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__outstanding_work_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t.outstanding_work_t [*outstanding_work_t]]]
+    [Default constructor. 
+     [hr]
+     Construct from a sub-property value. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The outstanding_work_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t.is_preferable [*is_preferable]]]
+    [The top-level outstanding_work_t property cannot be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t.is_requirable [*is_requirable]]]
+    [The top-level outstanding_work_t property cannot be required. ]
+  ]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t.tracked [*tracked]]]
+    [A special value used for accessing the outstanding_work_t::tracked_t property. ]
+  ]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t.untracked [*untracked]]]
+    [A special value used for accessing the outstanding_work_t::untracked_t property. ]
+  ]
+
+]
+
+[heading Friends]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t.operator_not__eq_ [*operator!=]]]
+    [Compare property values for inequality. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__outstanding_work_t.operator_eq__eq_ [*operator==]]]
+    [Compare property values for equality. ]
+  ]
+  
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/outstanding_work.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::outstanding_work_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t.is_applicable_property_v..is_applicable_property_v..execution::outstanding_work_t] 
+The [link asio.reference.execution__outstanding_work_t `execution::outstanding_work_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::outstanding_work_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t.is_preferable..is_preferable..execution::outstanding_work_t] 
+The top-level [link asio.reference.execution__outstanding_work_t `execution::outstanding_work_t`] property cannot be preferred. 
+
+
+  static constexpr bool is_preferable = false;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::outstanding_work_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t.is_requirable..is_requirable..execution::outstanding_work_t] 
+The top-level [link asio.reference.execution__outstanding_work_t `execution::outstanding_work_t`] property cannot be required. 
+
+
+  static constexpr bool is_requirable = false;
+
+
+
+[endsect]
+
+
+
+[section:operator_not__eq_ execution::outstanding_work_t::operator!=]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t.operator_not__eq_..operator!=..execution::outstanding_work_t] 
+Compare property values for inequality. 
+
+
+  friend constexpr bool operator!=(
+      const outstanding_work_t & a,
+      const outstanding_work_t & b);
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/outstanding_work.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:operator_eq__eq_ execution::outstanding_work_t::operator==]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t.operator_eq__eq_..operator==..execution::outstanding_work_t] 
+Compare property values for equality. 
+
+
+  friend constexpr bool operator==(
+      const outstanding_work_t & a,
+      const outstanding_work_t & b);
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/outstanding_work.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+[section:outstanding_work_t execution::outstanding_work_t::outstanding_work_t]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t.outstanding_work_t..outstanding_work_t..execution::outstanding_work_t] 
+Default constructor. 
+
+
+  constexpr ``[link asio.reference.execution__outstanding_work_t.outstanding_work_t.overload1 outstanding_work_t]``();
+  ``  [''''&raquo;''' [link asio.reference.execution__outstanding_work_t.outstanding_work_t.overload1 more...]]``
+
+
+Construct from a sub-property value. 
+
+
+  constexpr ``[link asio.reference.execution__outstanding_work_t.outstanding_work_t.overload2 outstanding_work_t]``(
+      untracked_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__outstanding_work_t.outstanding_work_t.overload2 more...]]``
+
+  constexpr ``[link asio.reference.execution__outstanding_work_t.outstanding_work_t.overload3 outstanding_work_t]``(
+      tracked_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__outstanding_work_t.outstanding_work_t.overload3 more...]]``
+
+
+[section:overload1 execution::outstanding_work_t::outstanding_work_t (1 of 3 overloads)]
+
+
+Default constructor. 
+
+
+  constexpr outstanding_work_t();
+
+
+
+[endsect]
+
+
+
+[section:overload2 execution::outstanding_work_t::outstanding_work_t (2 of 3 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr outstanding_work_t(
+      untracked_t );
+
+
+
+[endsect]
+
+
+
+[section:overload3 execution::outstanding_work_t::outstanding_work_t (3 of 3 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr outstanding_work_t(
+      tracked_t );
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:polymorphic_query_result_type execution::outstanding_work_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::outstanding_work_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef outstanding_work_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/outstanding_work.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:tracked execution::outstanding_work_t::tracked]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t.tracked..tracked..execution::outstanding_work_t] 
+A special value used for accessing the [link asio.reference.execution__outstanding_work_t__tracked_t `execution::outstanding_work_t::tracked_t`] property. 
+
+
+  static constexpr tracked_t tracked;
+
+
+
+[endsect]
+
+
+
+[section:untracked execution::outstanding_work_t::untracked]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t.untracked..untracked..execution::outstanding_work_t] 
+A special value used for accessing the [link asio.reference.execution__outstanding_work_t__untracked_t `execution::outstanding_work_t::untracked_t`] property. 
+
+
+  static constexpr untracked_t untracked;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__outstanding_work_t__tracked_t execution::outstanding_work_t::tracked_t]
+
+
+A sub-property that indicates that the executor represents likely future submission of a function object. 
+
+
+  struct tracked_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__outstanding_work_t__tracked_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t__tracked_t.tracked_t [*tracked_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__outstanding_work_t__tracked_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t__tracked_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The outstanding_work_t::tracked_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t__tracked_t.is_preferable [*is_preferable]]]
+    [The outstanding_work_t::tracked_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t__tracked_t.is_requirable [*is_requirable]]]
+    [The outstanding_work_t::tracked_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/outstanding_work.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::outstanding_work_t::tracked_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t__tracked_t.is_applicable_property_v..is_applicable_property_v..execution::outstanding_work_t::tracked_t] 
+The [link asio.reference.execution__outstanding_work_t__tracked_t `execution::outstanding_work_t::tracked_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::outstanding_work_t::tracked_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t__tracked_t.is_preferable..is_preferable..execution::outstanding_work_t::tracked_t] 
+The [link asio.reference.execution__outstanding_work_t__tracked_t `execution::outstanding_work_t::tracked_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::outstanding_work_t::tracked_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t__tracked_t.is_requirable..is_requirable..execution::outstanding_work_t::tracked_t] 
+The [link asio.reference.execution__outstanding_work_t__tracked_t `execution::outstanding_work_t::tracked_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::outstanding_work_t::tracked_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t__tracked_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::outstanding_work_t::tracked_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef outstanding_work_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/outstanding_work.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:tracked_t execution::outstanding_work_t::tracked_t::tracked_t]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t__tracked_t.tracked_t..tracked_t..execution::outstanding_work_t::tracked_t] 
+Default constructor. 
+
+
+  constexpr tracked_t();
+
+
+
+[endsect]
+
+
+
+[section:value execution::outstanding_work_t::tracked_t::value]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t__tracked_t.value..value..execution::outstanding_work_t::tracked_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr outstanding_work_t value();
+
+
+
+[heading Return Value]
+      
+`tracked_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__outstanding_work_t__untracked_t execution::outstanding_work_t::untracked_t]
+
+
+A sub-property that indicates that the executor does not represent likely future submission of a function object. 
+
+
+  struct untracked_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__outstanding_work_t__untracked_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t__untracked_t.untracked_t [*untracked_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__outstanding_work_t__untracked_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t__untracked_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The outstanding_work_t::untracked_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t__untracked_t.is_preferable [*is_preferable]]]
+    [The outstanding_work_t::untracked_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__outstanding_work_t__untracked_t.is_requirable [*is_requirable]]]
+    [The outstanding_work_t::untracked_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/outstanding_work.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::outstanding_work_t::untracked_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t__untracked_t.is_applicable_property_v..is_applicable_property_v..execution::outstanding_work_t::untracked_t] 
+The [link asio.reference.execution__outstanding_work_t__untracked_t `execution::outstanding_work_t::untracked_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::outstanding_work_t::untracked_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t__untracked_t.is_preferable..is_preferable..execution::outstanding_work_t::untracked_t] 
+The [link asio.reference.execution__outstanding_work_t__untracked_t `execution::outstanding_work_t::untracked_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::outstanding_work_t::untracked_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t__untracked_t.is_requirable..is_requirable..execution::outstanding_work_t::untracked_t] 
+The [link asio.reference.execution__outstanding_work_t__untracked_t `execution::outstanding_work_t::untracked_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::outstanding_work_t::untracked_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t__untracked_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::outstanding_work_t::untracked_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef outstanding_work_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/outstanding_work.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:untracked_t execution::outstanding_work_t::untracked_t::untracked_t]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t__untracked_t.untracked_t..untracked_t..execution::outstanding_work_t::untracked_t] 
+Default constructor. 
+
+
+  constexpr untracked_t();
+
+
+
+[endsect]
+
+
+
+[section:value execution::outstanding_work_t::untracked_t::value]
+
+[indexterm2 asio.indexterm.execution__outstanding_work_t__untracked_t.value..value..execution::outstanding_work_t::untracked_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr outstanding_work_t value();
+
+
+
+[heading Return Value]
+      
+`untracked_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__prefer_only execution::prefer_only]
+
+
+A property that is used to obtain the execution context that is associated with an executor. 
+
+
+  template<
+      typename Property>
+  struct prefer_only
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__prefer_only.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__prefer_only.is_applicable_property_v [*is_applicable_property_v]]]
+    [The context_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__prefer_only.is_preferable [*is_preferable]]]
+    [The context_t property can be preferred, it the underlying property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__prefer_only.is_requirable [*is_requirable]]]
+    [The context_t property cannot be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/prefer_only.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:is_applicable_property_v execution::prefer_only::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__prefer_only.is_applicable_property_v..is_applicable_property_v..execution::prefer_only] 
+The [link asio.reference.execution__context_t `execution::context_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::prefer_only::is_preferable]
+
+[indexterm2 asio.indexterm.execution__prefer_only.is_preferable..is_preferable..execution::prefer_only] 
+The [link asio.reference.execution__context_t `execution::context_t`] property can be preferred, it the underlying property can be preferred. 
+
+
+  static constexpr bool is_preferable = automatically_determined;
+
+
+`true` if `Property::is_preferable` is `true`, otherwise `false`. 
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::prefer_only::is_requirable]
+
+[indexterm2 asio.indexterm.execution__prefer_only.is_requirable..is_requirable..execution::prefer_only] 
+The [link asio.reference.execution__context_t `execution::context_t`] property cannot be required. 
+
+
+  static constexpr bool is_requirable = false;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::prefer_only::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__prefer_only.polymorphic_query_result_type..polymorphic_query_result_type..execution::prefer_only] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef Property::polymorphic_query_result_type polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/prefer_only.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:execution__relationship execution::relationship]
+
+[indexterm1 asio.indexterm.execution__relationship..execution::relationship] 
+A special value used for accessing the [link asio.reference.execution__relationship_t `execution::relationship_t`] property. 
+
+
+  constexpr relationship_t relationship;
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/relationship.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+[section:execution__relationship_t execution::relationship_t]
+
+
+A property to describe whether submitted tasks represent continuations of the calling context. 
+
+
+  struct relationship_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__relationship_t__continuation_t [*continuation_t]]]
+    [A sub-property that indicates that the executor represents a continuation of the calling context. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__relationship_t__fork_t [*fork_t]]]
+    [A sub-property that indicates that the executor does not represent a continuation of the calling context. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.execution__relationship_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__relationship_t.relationship_t [*relationship_t]]]
+    [Default constructor. 
+     [hr]
+     Construct from a sub-property value. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__relationship_t.continuation [*continuation]]]
+    [A special value used for accessing the relationship_t::continuation_t property. ]
+  ]
+
+  [
+    [[link asio.reference.execution__relationship_t.fork [*fork]]]
+    [A special value used for accessing the relationship_t::fork_t property. ]
+  ]
+
+  [
+    [[link asio.reference.execution__relationship_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The relationship_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__relationship_t.is_preferable [*is_preferable]]]
+    [The top-level relationship_t property cannot be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__relationship_t.is_requirable [*is_requirable]]]
+    [The top-level relationship_t property cannot be required. ]
+  ]
+
+]
+
+[heading Friends]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__relationship_t.operator_not__eq_ [*operator!=]]]
+    [Compare property values for inequality. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__relationship_t.operator_eq__eq_ [*operator==]]]
+    [Compare property values for equality. ]
+  ]
+  
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/relationship.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:continuation execution::relationship_t::continuation]
+
+[indexterm2 asio.indexterm.execution__relationship_t.continuation..continuation..execution::relationship_t] 
+A special value used for accessing the [link asio.reference.execution__relationship_t__continuation_t `execution::relationship_t::continuation_t`] property. 
+
+
+  static constexpr continuation_t continuation;
+
+
+
+[endsect]
+
+
+
+[section:fork execution::relationship_t::fork]
+
+[indexterm2 asio.indexterm.execution__relationship_t.fork..fork..execution::relationship_t] 
+A special value used for accessing the [link asio.reference.execution__relationship_t__fork_t `execution::relationship_t::fork_t`] property. 
+
+
+  static constexpr fork_t fork;
+
+
+
+[endsect]
+
+
+
+[section:is_applicable_property_v execution::relationship_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__relationship_t.is_applicable_property_v..is_applicable_property_v..execution::relationship_t] 
+The [link asio.reference.execution__relationship_t `execution::relationship_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::relationship_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__relationship_t.is_preferable..is_preferable..execution::relationship_t] 
+The top-level [link asio.reference.execution__relationship_t `execution::relationship_t`] property cannot be preferred. 
+
+
+  static constexpr bool is_preferable = false;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::relationship_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__relationship_t.is_requirable..is_requirable..execution::relationship_t] 
+The top-level [link asio.reference.execution__relationship_t `execution::relationship_t`] property cannot be required. 
+
+
+  static constexpr bool is_requirable = false;
+
+
+
+[endsect]
+
+
+
+[section:operator_not__eq_ execution::relationship_t::operator!=]
+
+[indexterm2 asio.indexterm.execution__relationship_t.operator_not__eq_..operator!=..execution::relationship_t] 
+Compare property values for inequality. 
+
+
+  friend constexpr bool operator!=(
+      const relationship_t & a,
+      const relationship_t & b);
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/relationship.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:operator_eq__eq_ execution::relationship_t::operator==]
+
+[indexterm2 asio.indexterm.execution__relationship_t.operator_eq__eq_..operator==..execution::relationship_t] 
+Compare property values for equality. 
+
+
+  friend constexpr bool operator==(
+      const relationship_t & a,
+      const relationship_t & b);
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/relationship.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::relationship_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__relationship_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::relationship_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef relationship_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/relationship.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+[section:relationship_t execution::relationship_t::relationship_t]
+
+[indexterm2 asio.indexterm.execution__relationship_t.relationship_t..relationship_t..execution::relationship_t] 
+Default constructor. 
+
+
+  constexpr ``[link asio.reference.execution__relationship_t.relationship_t.overload1 relationship_t]``();
+  ``  [''''&raquo;''' [link asio.reference.execution__relationship_t.relationship_t.overload1 more...]]``
+
+
+Construct from a sub-property value. 
+
+
+  constexpr ``[link asio.reference.execution__relationship_t.relationship_t.overload2 relationship_t]``(
+      fork_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__relationship_t.relationship_t.overload2 more...]]``
+
+  constexpr ``[link asio.reference.execution__relationship_t.relationship_t.overload3 relationship_t]``(
+      continuation_t );
+  ``  [''''&raquo;''' [link asio.reference.execution__relationship_t.relationship_t.overload3 more...]]``
+
+
+[section:overload1 execution::relationship_t::relationship_t (1 of 3 overloads)]
+
+
+Default constructor. 
+
+
+  constexpr relationship_t();
+
+
+
+[endsect]
+
+
+
+[section:overload2 execution::relationship_t::relationship_t (2 of 3 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr relationship_t(
+      fork_t );
+
+
+
+[endsect]
+
+
+
+[section:overload3 execution::relationship_t::relationship_t (3 of 3 overloads)]
+
+
+Construct from a sub-property value. 
+
+
+  constexpr relationship_t(
+      continuation_t );
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[endsect]
+
+[section:execution__relationship_t__continuation_t execution::relationship_t::continuation_t]
+
+
+A sub-property that indicates that the executor represents a continuation of the calling context. 
+
+
+  struct continuation_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__relationship_t__continuation_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__relationship_t__continuation_t.continuation_t [*continuation_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__relationship_t__continuation_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__relationship_t__continuation_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The relationship_t::continuation_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__relationship_t__continuation_t.is_preferable [*is_preferable]]]
+    [The relationship_t::continuation_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__relationship_t__continuation_t.is_requirable [*is_requirable]]]
+    [The relationship_t::continuation_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/relationship.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:continuation_t execution::relationship_t::continuation_t::continuation_t]
+
+[indexterm2 asio.indexterm.execution__relationship_t__continuation_t.continuation_t..continuation_t..execution::relationship_t::continuation_t] 
+Default constructor. 
+
+
+  constexpr continuation_t();
+
+
+
+[endsect]
+
+
+
+[section:is_applicable_property_v execution::relationship_t::continuation_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__relationship_t__continuation_t.is_applicable_property_v..is_applicable_property_v..execution::relationship_t::continuation_t] 
+The [link asio.reference.execution__relationship_t__continuation_t `execution::relationship_t::continuation_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::relationship_t::continuation_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__relationship_t__continuation_t.is_preferable..is_preferable..execution::relationship_t::continuation_t] 
+The [link asio.reference.execution__relationship_t__continuation_t `execution::relationship_t::continuation_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::relationship_t::continuation_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__relationship_t__continuation_t.is_requirable..is_requirable..execution::relationship_t::continuation_t] 
+The [link asio.reference.execution__relationship_t__continuation_t `execution::relationship_t::continuation_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::relationship_t::continuation_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__relationship_t__continuation_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::relationship_t::continuation_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef relationship_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/relationship.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:value execution::relationship_t::continuation_t::value]
+
+[indexterm2 asio.indexterm.execution__relationship_t__continuation_t.value..value..execution::relationship_t::continuation_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr relationship_t value();
+
+
+
+[heading Return Value]
+      
+`continuation_t()`; 
+
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:execution__relationship_t__fork_t execution::relationship_t::fork_t]
+
+
+A sub-property that indicates that the executor does not represent a continuation of the calling context. 
+
+
+  struct fork_t
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.execution__relationship_t__fork_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
+    [The type returned by queries against an any_executor. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__relationship_t__fork_t.fork_t [*fork_t]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.execution__relationship_t__fork_t.value [*value]]]
+    [Get the value associated with a property object. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.execution__relationship_t__fork_t.is_applicable_property_v [*is_applicable_property_v]]]
+    [The relationship_t::fork_t property applies to executors. ]
+  ]
+
+  [
+    [[link asio.reference.execution__relationship_t__fork_t.is_preferable [*is_preferable]]]
+    [The relationship_t::fork_t property can be preferred. ]
+  ]
+
+  [
+    [[link asio.reference.execution__relationship_t__fork_t.is_requirable [*is_requirable]]]
+    [The relationship_t::fork_t property can be required. ]
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^asio/execution/relationship.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[section:fork_t execution::relationship_t::fork_t::fork_t]
+
+[indexterm2 asio.indexterm.execution__relationship_t__fork_t.fork_t..fork_t..execution::relationship_t::fork_t] 
+Default constructor. 
+
+
+  constexpr fork_t();
+
+
+
+[endsect]
+
+
+
+[section:is_applicable_property_v execution::relationship_t::fork_t::is_applicable_property_v]
+
+[indexterm2 asio.indexterm.execution__relationship_t__fork_t.is_applicable_property_v..is_applicable_property_v..execution::relationship_t::fork_t] 
+The [link asio.reference.execution__relationship_t__fork_t `execution::relationship_t::fork_t`] property applies to executors. 
+
+
+  template <typename T>
+  static constexpr bool is_applicable_property_v = is_executor_v<T>;
+
+
+
+[endsect]
+
+
+
+[section:is_preferable execution::relationship_t::fork_t::is_preferable]
+
+[indexterm2 asio.indexterm.execution__relationship_t__fork_t.is_preferable..is_preferable..execution::relationship_t::fork_t] 
+The [link asio.reference.execution__relationship_t__fork_t `execution::relationship_t::fork_t`] property can be preferred. 
+
+
+  static constexpr bool is_preferable = true;
+
+
+
+[endsect]
+
+
+
+[section:is_requirable execution::relationship_t::fork_t::is_requirable]
+
+[indexterm2 asio.indexterm.execution__relationship_t__fork_t.is_requirable..is_requirable..execution::relationship_t::fork_t] 
+The [link asio.reference.execution__relationship_t__fork_t `execution::relationship_t::fork_t`] property can be required. 
+
+
+  static constexpr bool is_requirable = true;
+
+
+
+[endsect]
+
+
+
+[section:polymorphic_query_result_type execution::relationship_t::fork_t::polymorphic_query_result_type]
+
+[indexterm2 asio.indexterm.execution__relationship_t__fork_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::relationship_t::fork_t] 
+The type returned by queries against an `any_executor`. 
+
+
+  typedef relationship_t polymorphic_query_result_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/execution/relationship.hpp]
+
+['Convenience header: ][^asio/execution.hpp]
+
+
+[endsect]
+
+
+
+[section:value execution::relationship_t::fork_t::value]
+
+[indexterm2 asio.indexterm.execution__relationship_t__fork_t.value..value..execution::relationship_t::fork_t] 
+Get the value associated with a property object. 
+
+
+  static constexpr relationship_t value();
+
+
+
+[heading Return Value]
+      
+`fork_t()`; 
+
+
+
+
+[endsect]
+
+
+
 [endsect]
 
 [section:execution_context execution_context]
@@ -63151,7 +70831,7 @@ This destruction sequence permits programs to simplify their resource management
 
 ['Header: ][^asio/execution_context.hpp]
 
-['Convenience header: ][^asio.hpp]
+['Convenience header: ][^asio/execution.hpp]
 
 
 [section:add_service execution_context::add_service]
@@ -63203,7 +70883,7 @@ This function is used to add a service to the [link asio.reference.execution_con
 
 ['Header: ][^asio/execution_context.hpp]
 
-['Convenience header: ][^asio.hpp]
+['Convenience header: ][^asio/execution.hpp]
 
 
 [endsect]
@@ -63318,7 +70998,7 @@ A boolean indicating whether the [link asio.reference.execution_context `executi
 
 ['Header: ][^asio/execution_context.hpp]
 
-['Convenience header: ][^asio.hpp]
+['Convenience header: ][^asio/execution.hpp]
 
 
 [endsect]
@@ -63369,7 +71049,7 @@ This function is used to add a service to the [link asio.reference.execution_con
 
 ['Header: ][^asio/execution_context.hpp]
 
-['Convenience header: ][^asio.hpp]
+['Convenience header: ][^asio/execution.hpp]
 
 
 [endsect]
@@ -63516,7 +71196,7 @@ The service interface implementing the specified service type. Ownership of the
 
 ['Header: ][^asio/execution_context.hpp]
 
-['Convenience header: ][^asio.hpp]
+['Convenience header: ][^asio/execution.hpp]
 
 
 [endsect]
@@ -63563,7 +71243,7 @@ This overload is preserved for backwards compatibility with services that inheri
 
 ['Header: ][^asio/execution_context.hpp]
 
-['Convenience header: ][^asio.hpp]
+['Convenience header: ][^asio/execution.hpp]
 
 
 [endsect]
@@ -63613,7 +71293,7 @@ Class used to uniquely identify a service.
 
 ['Header: ][^asio/execution_context.hpp]
 
-['Convenience header: ][^asio.hpp]
+['Convenience header: ][^asio/execution.hpp]
 
 
 [section:id execution_context::id::id]
@@ -63689,7 +71369,7 @@ Base class for all [link asio.reference.io_context `io_context`] services.
 
 ['Header: ][^asio/execution_context.hpp]
 
-['Convenience header: ][^asio.hpp]
+['Convenience header: ][^asio/execution.hpp]
 
 
 [section:context execution_context::service::context]
@@ -69629,7 +77309,7 @@ Helper function to obtain an object's associated executor.
   associated_executor< T, Executor >::type ``[link asio.reference.get_associated_executor.overload2 get_associated_executor]``(
       const T & t,
       const Executor & ex,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.get_associated_executor.overload2 more...]]``
 
   template<
@@ -69684,7 +77364,7 @@ Helper function to obtain an object's associated executor.
   associated_executor< T, Executor >::type get_associated_executor(
       const T & t,
       const Executor & ex,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
 
 
 
@@ -70008,7 +77688,7 @@ Exception thrown when trying to add a service object to an [link asio.reference.
 
 ['Header: ][^asio/execution_context.hpp]
 
-['Convenience header: ][^asio.hpp]
+['Convenience header: ][^asio/execution.hpp]
 
 
 [section:invalid_service_owner invalid_service_owner::invalid_service_owner]
@@ -70041,8 +77721,8 @@ Provides core I/O functionality.
 
   [
 
-    [[link asio.reference.io_context__executor_type [*executor_type]]]
-    [Executor used to submit functions to an io_context. ]
+    [[link asio.reference.io_context__basic_executor_type [*basic_executor_type]]]
+    [Executor implementation type used to submit functions to an io_context. ]
   
   ]
 
@@ -70074,6 +77754,13 @@ Provides core I/O functionality.
   
   ]
 
+  [
+
+    [[link asio.reference.io_context.executor_type [*executor_type]]]
+    [Executor used to submit functions to an io_context. ]
+  
+  ]
+
   [
 
     [[link asio.reference.io_context.fork_event [*fork_event]]]
@@ -70336,13 +78023,41 @@ For example:
   
 
 
-Some applications may need to prevent an [link asio.reference.io_context `io_context`] object's `run()` call from returning when there is no more work to do. For example, the [link asio.reference.io_context `io_context`] may be being run in a background thread that is launched prior to the application's asynchronous operations. The `run()` call may be kept running by creating an object of type asio::executor\_work\_guard<io\_context::executor\_type>:
+Some applications may need to prevent an [link asio.reference.io_context `io_context`] object's `run()` call from returning when there is no more work to do. For example, the [link asio.reference.io_context `io_context`] may be being run in a background thread that is launched prior to the application's asynchronous operations. The `run()` call may be kept running by creating an executor that tracks work against the [link asio.reference.io_context `io_context`]:
 
 
 
    asio::io_context io_context;
-   asio::executor_work_guard<asio::io_context::executor_type>
-     = asio::make_work_guard(io_context);
+   auto work = asio::require(io_context.get_executor(),
+       asio::execution::outstanding_work.tracked);
+   ... 
+
+
+
+
+If using C++03, which lacks automatic variable type deduction, you may compute the return type of the require call:
+
+
+
+   asio::io_context io_context;
+   typename asio::require_result_type<
+       asio::io_context::executor_type,
+       asio::exeution::outstanding_work_t::tracked_t>
+     work = asio::require(io_context.get_executor(),
+       asio::execution::outstanding_work.tracked);
+   ... 
+
+
+
+
+or store the result in the type-erasing executor wrapper, any\_io\_executor:
+
+
+
+   asio::io_context io_context;
+   asio::any_io_executor work
+     = asio::require(io_context.get_executor(),
+         asio::execution::outstanding_work.tracked);
    ... 
 
 
@@ -70350,15 +78065,16 @@ Some applications may need to prevent an [link asio.reference.io_context `io_con
 
 To effect a shutdown, the application will then need to call the [link asio.reference.io_context `io_context`] object's `stop()` member function. This will cause the [link asio.reference.io_context `io_context`] `run()` call to return as soon as possible, abandoning unfinished operations and without permitting ready handlers to be dispatched.
 
-Alternatively, if the application requires that all operations and handlers be allowed to finish normally, the work object may be explicitly reset.
+Alternatively, if the application requires that all operations and handlers be allowed to finish normally, store the work-tracking executor in an any\_io\_executor object, so that it may be explicitly reset.
 
 
 
    asio::io_context io_context;
-   asio::executor_work_guard<asio::io_context::executor_type>
-     = asio::make_work_guard(io_context);
+   asio::any_io_executor work
+     = asio::require(io_context.get_executor(),
+         asio::execution::outstanding_work.tracked);
    ...
-   work.reset(); // Allow run() to exit. 
+   work = asio::any_io_executor(); // Allow run() to exit. 
 
 
 
@@ -70522,6 +78238,145 @@ throws an exception.
 
 
 
+[section:executor_type io_context::executor_type]
+
+[indexterm2 asio.indexterm.io_context.executor_type..executor_type..io_context] 
+Executor used to submit functions to an [link asio.reference.io_context `io_context`]. 
+
+
+  typedef basic_executor_type< std::allocator< void >, 0 > executor_type;
+
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.io_context__basic_executor_type.basic_executor_type [*basic_executor_type]]]
+    [Copy construtor. 
+     [hr]
+     Move construtor. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.context [*context]]]
+    [Obtain the underlying execution context. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.defer [*defer]]]
+    [Request the io_context to invoke the given function object. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.dispatch [*dispatch]]]
+    [Request the io_context to invoke the given function object. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.execute [*execute]]]
+    [Execution function. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.on_work_finished [*on_work_finished]]]
+    [Inform the io_context that some work is no longer outstanding. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.on_work_started [*on_work_started]]]
+    [Inform the io_context that it has some outstanding work to do. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.operator_eq_ [*operator=]]]
+    [Assignment operator. 
+     [hr]
+     Move assignment operator. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.post [*post]]]
+    [Request the io_context to invoke the given function object. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.query [*query]]]
+    [Query the current value of the context property. 
+     [hr]
+     Query the current value of the blocking property. 
+     [hr]
+     Query the current value of the relationship property. 
+     [hr]
+     Query the current value of the allocator property. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.query__static [*query]]]
+    [Query the current value of the mapping property. 
+     [hr]
+     Query the current value of the outstanding_work property. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.require [*require]]]
+    [Obtain an executor with the blocking.possibly property. 
+     [hr]
+     Obtain an executor with the blocking.never property. 
+     [hr]
+     Obtain an executor with the relationship.fork property. 
+     [hr]
+     Obtain an executor with the relationship.continuation property. 
+     [hr]
+     Obtain an executor with the outstanding_work.tracked property. 
+     [hr]
+     Obtain an executor with the outstanding_work.untracked property. 
+     [hr]
+     Obtain an executor with the specified allocator property. 
+     [hr]
+     Obtain an executor with the default allocator property. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.running_in_this_thread [*running_in_this_thread]]]
+    [Determine whether the io_context is running in the current thread. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type._basic_executor_type [*~basic_executor_type]]]
+    [Destructor. ]
+  ]
+  
+]
+
+[heading Friends]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.io_context__basic_executor_type.operator_not__eq_ [*operator!=]]]
+    [Compare two executors for inequality. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.operator_eq__eq_ [*operator==]]]
+    [Compare two executors for equality. ]
+  ]
+  
+]
+
+
+[heading Requirements]
+
+['Header: ][^asio/io_context.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+
 [section:fork_event io_context::fork_event]
 
 
@@ -71610,13 +79465,16 @@ The destruction sequence described above permits programs to simplify their reso
 
 [endsect]
 
-[section:io_context__executor_type io_context::executor_type]
+[section:io_context__basic_executor_type io_context::basic_executor_type]
 
 
-Executor used to submit functions to an [link asio.reference.io_context `io_context`]. 
+Executor implementation type used to submit functions to an [link asio.reference.io_context `io_context`]. 
 
 
-  class executor_type
+  template<
+      typename Allocator,
+      unsigned int Bits>
+  class basic_executor_type
 
 
 [heading Member Functions]
@@ -71624,40 +79482,101 @@ Executor used to submit functions to an [link asio.reference.io_context `io_cont
   [[Name][Description]]
 
   [
-    [[link asio.reference.io_context__executor_type.context [*context]]]
+    [[link asio.reference.io_context__basic_executor_type.basic_executor_type [*basic_executor_type]]]
+    [Copy construtor. 
+     [hr]
+     Move construtor. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.context [*context]]]
     [Obtain the underlying execution context. ]
   ]
   
   [
-    [[link asio.reference.io_context__executor_type.defer [*defer]]]
+    [[link asio.reference.io_context__basic_executor_type.defer [*defer]]]
     [Request the io_context to invoke the given function object. ]
   ]
   
   [
-    [[link asio.reference.io_context__executor_type.dispatch [*dispatch]]]
+    [[link asio.reference.io_context__basic_executor_type.dispatch [*dispatch]]]
     [Request the io_context to invoke the given function object. ]
   ]
   
   [
-    [[link asio.reference.io_context__executor_type.on_work_finished [*on_work_finished]]]
+    [[link asio.reference.io_context__basic_executor_type.execute [*execute]]]
+    [Execution function. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.on_work_finished [*on_work_finished]]]
     [Inform the io_context that some work is no longer outstanding. ]
   ]
   
   [
-    [[link asio.reference.io_context__executor_type.on_work_started [*on_work_started]]]
+    [[link asio.reference.io_context__basic_executor_type.on_work_started [*on_work_started]]]
     [Inform the io_context that it has some outstanding work to do. ]
   ]
   
   [
-    [[link asio.reference.io_context__executor_type.post [*post]]]
+    [[link asio.reference.io_context__basic_executor_type.operator_eq_ [*operator=]]]
+    [Assignment operator. 
+     [hr]
+     Move assignment operator. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.post [*post]]]
     [Request the io_context to invoke the given function object. ]
   ]
   
   [
-    [[link asio.reference.io_context__executor_type.running_in_this_thread [*running_in_this_thread]]]
+    [[link asio.reference.io_context__basic_executor_type.query [*query]]]
+    [Query the current value of the context property. 
+     [hr]
+     Query the current value of the blocking property. 
+     [hr]
+     Query the current value of the relationship property. 
+     [hr]
+     Query the current value of the allocator property. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.query__static [*query]]]
+    [Query the current value of the mapping property. 
+     [hr]
+     Query the current value of the outstanding_work property. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.require [*require]]]
+    [Obtain an executor with the blocking.possibly property. 
+     [hr]
+     Obtain an executor with the blocking.never property. 
+     [hr]
+     Obtain an executor with the relationship.fork property. 
+     [hr]
+     Obtain an executor with the relationship.continuation property. 
+     [hr]
+     Obtain an executor with the outstanding_work.tracked property. 
+     [hr]
+     Obtain an executor with the outstanding_work.untracked property. 
+     [hr]
+     Obtain an executor with the specified allocator property. 
+     [hr]
+     Obtain an executor with the default allocator property. ]
+  ]
+  
+  [
+    [[link asio.reference.io_context__basic_executor_type.running_in_this_thread [*running_in_this_thread]]]
     [Determine whether the io_context is running in the current thread. ]
   ]
   
+  [
+    [[link asio.reference.io_context__basic_executor_type._basic_executor_type [*~basic_executor_type]]]
+    [Destructor. ]
+  ]
+  
 ]
 
 [heading Friends]
@@ -71665,12 +79584,12 @@ Executor used to submit functions to an [link asio.reference.io_context `io_cont
   [[Name][Description]]
 
   [
-    [[link asio.reference.io_context__executor_type.operator_not__eq_ [*operator!=]]]
+    [[link asio.reference.io_context__basic_executor_type.operator_not__eq_ [*operator!=]]]
     [Compare two executors for inequality. ]
   ]
   
   [
-    [[link asio.reference.io_context__executor_type.operator_eq__eq_ [*operator==]]]
+    [[link asio.reference.io_context__basic_executor_type.operator_eq__eq_ [*operator==]]]
     [Compare two executors for equality. ]
   ]
   
@@ -71682,10 +79601,60 @@ Executor used to submit functions to an [link asio.reference.io_context `io_cont
 
 ['Convenience header: ][^asio.hpp]
 
+[section:basic_executor_type io_context::basic_executor_type::basic_executor_type]
 
-[section:context io_context::executor_type::context]
+[indexterm2 asio.indexterm.io_context__basic_executor_type.basic_executor_type..basic_executor_type..io_context::basic_executor_type] 
+Copy construtor. 
 
-[indexterm2 asio.indexterm.io_context__executor_type.context..context..io_context::executor_type] 
+
+  ``[link asio.reference.io_context__basic_executor_type.basic_executor_type.overload1 basic_executor_type]``(
+      const basic_executor_type & other);
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.basic_executor_type.overload1 more...]]``
+
+
+Move construtor. 
+
+
+  ``[link asio.reference.io_context__basic_executor_type.basic_executor_type.overload2 basic_executor_type]``(
+      basic_executor_type && other);
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.basic_executor_type.overload2 more...]]``
+
+
+[section:overload1 io_context::basic_executor_type::basic_executor_type (1 of 2 overloads)]
+
+
+Copy construtor. 
+
+
+  basic_executor_type(
+      const basic_executor_type & other);
+
+
+
+[endsect]
+
+
+
+[section:overload2 io_context::basic_executor_type::basic_executor_type (2 of 2 overloads)]
+
+
+Move construtor. 
+
+
+  basic_executor_type(
+      basic_executor_type && other);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:context io_context::basic_executor_type::context]
+
+[indexterm2 asio.indexterm.io_context__basic_executor_type.context..context..io_context::basic_executor_type] 
 Obtain the underlying execution context. 
 
 
@@ -71697,18 +79666,18 @@ Obtain the underlying execution context.
 
 
 
-[section:defer io_context::executor_type::defer]
+[section:defer io_context::basic_executor_type::defer]
 
-[indexterm2 asio.indexterm.io_context__executor_type.defer..defer..io_context::executor_type] 
+[indexterm2 asio.indexterm.io_context__basic_executor_type.defer..defer..io_context::basic_executor_type] 
 Request the [link asio.reference.io_context `io_context`] to invoke the given function object. 
 
 
   template<
       typename Function,
-      typename Allocator>
+      typename OtherAllocator>
   void defer(
       Function && f,
-      const Allocator & a) const;
+      const OtherAllocator & a) const;
 
 
 This function is used to ask the [link asio.reference.io_context `io_context`] to execute the given function object. The function object will never be executed inside `defer()`. Instead, it will be scheduled to run on the [link asio.reference.io_context `io_context`].
@@ -71738,18 +79707,18 @@ If the current thread belongs to the [link asio.reference.io_context `io_context
 
 
 
-[section:dispatch io_context::executor_type::dispatch]
+[section:dispatch io_context::basic_executor_type::dispatch]
 
-[indexterm2 asio.indexterm.io_context__executor_type.dispatch..dispatch..io_context::executor_type] 
+[indexterm2 asio.indexterm.io_context__basic_executor_type.dispatch..dispatch..io_context::basic_executor_type] 
 Request the [link asio.reference.io_context `io_context`] to invoke the given function object. 
 
 
   template<
       typename Function,
-      typename Allocator>
+      typename OtherAllocator>
   void dispatch(
       Function && f,
-      const Allocator & a) const;
+      const OtherAllocator & a) const;
 
 
 This function is used to ask the [link asio.reference.io_context `io_context`] to execute the given function object. If the current thread is running the [link asio.reference.io_context `io_context`], `dispatch()` executes the function before returning. Otherwise, the function will be scheduled to run on the [link asio.reference.io_context `io_context`].
@@ -71777,9 +79746,26 @@ This function is used to ask the [link asio.reference.io_context `io_context`] t
 
 
 
-[section:on_work_finished io_context::executor_type::on_work_finished]
+[section:execute io_context::basic_executor_type::execute]
 
-[indexterm2 asio.indexterm.io_context__executor_type.on_work_finished..on_work_finished..io_context::executor_type] 
+[indexterm2 asio.indexterm.io_context__basic_executor_type.execute..execute..io_context::basic_executor_type] 
+Execution function. 
+
+
+  template<
+      typename Function>
+  void execute(
+      Function && f) const;
+
+
+
+[endsect]
+
+
+
+[section:on_work_finished io_context::basic_executor_type::on_work_finished]
+
+[indexterm2 asio.indexterm.io_context__basic_executor_type.on_work_finished..on_work_finished..io_context::basic_executor_type] 
 Inform the [link asio.reference.io_context `io_context`] that some work is no longer outstanding. 
 
 
@@ -71793,9 +79779,9 @@ This function is used to inform the [link asio.reference.io_context `io_context`
 
 
 
-[section:on_work_started io_context::executor_type::on_work_started]
+[section:on_work_started io_context::basic_executor_type::on_work_started]
 
-[indexterm2 asio.indexterm.io_context__executor_type.on_work_started..on_work_started..io_context::executor_type] 
+[indexterm2 asio.indexterm.io_context__basic_executor_type.on_work_started..on_work_started..io_context::basic_executor_type] 
 Inform the [link asio.reference.io_context `io_context`] that it has some outstanding work to do. 
 
 
@@ -71809,15 +79795,15 @@ This function is used to inform the [link asio.reference.io_context `io_context`
 
 
 
-[section:operator_not__eq_ io_context::executor_type::operator!=]
+[section:operator_not__eq_ io_context::basic_executor_type::operator!=]
 
-[indexterm2 asio.indexterm.io_context__executor_type.operator_not__eq_..operator!=..io_context::executor_type] 
+[indexterm2 asio.indexterm.io_context__basic_executor_type.operator_not__eq_..operator!=..io_context::basic_executor_type] 
 Compare two executors for inequality. 
 
 
   friend bool operator!=(
-      const executor_type & a,
-      const executor_type & b);
+      const basic_executor_type & a,
+      const basic_executor_type & b);
 
 
 Two executors are equal if they refer to the same underlying [link asio.reference.io_context `io_context`]. 
@@ -71832,16 +79818,66 @@ Two executors are equal if they refer to the same underlying [link asio.referenc
 [endsect]
 
 
+[section:operator_eq_ io_context::basic_executor_type::operator=]
 
-[section:operator_eq__eq_ io_context::executor_type::operator==]
+[indexterm2 asio.indexterm.io_context__basic_executor_type.operator_eq_..operator=..io_context::basic_executor_type] 
+Assignment operator. 
 
-[indexterm2 asio.indexterm.io_context__executor_type.operator_eq__eq_..operator==..io_context::executor_type] 
+
+  basic_executor_type & ``[link asio.reference.io_context__basic_executor_type.operator_eq_.overload1 operator=]``(
+      const basic_executor_type & other);
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.operator_eq_.overload1 more...]]``
+
+
+Move assignment operator. 
+
+
+  basic_executor_type & ``[link asio.reference.io_context__basic_executor_type.operator_eq_.overload2 operator=]``(
+      basic_executor_type && other);
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.operator_eq_.overload2 more...]]``
+
+
+[section:overload1 io_context::basic_executor_type::operator= (1 of 2 overloads)]
+
+
+Assignment operator. 
+
+
+  basic_executor_type & operator=(
+      const basic_executor_type & other);
+
+
+
+[endsect]
+
+
+
+[section:overload2 io_context::basic_executor_type::operator= (2 of 2 overloads)]
+
+
+Move assignment operator. 
+
+
+  basic_executor_type & operator=(
+      basic_executor_type && other);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:operator_eq__eq_ io_context::basic_executor_type::operator==]
+
+[indexterm2 asio.indexterm.io_context__basic_executor_type.operator_eq__eq_..operator==..io_context::basic_executor_type] 
 Compare two executors for equality. 
 
 
   friend bool operator==(
-      const executor_type & a,
-      const executor_type & b);
+      const basic_executor_type & a,
+      const basic_executor_type & b);
 
 
 Two executors are equal if they refer to the same underlying [link asio.reference.io_context `io_context`]. 
@@ -71857,18 +79893,18 @@ Two executors are equal if they refer to the same underlying [link asio.referenc
 
 
 
-[section:post io_context::executor_type::post]
+[section:post io_context::basic_executor_type::post]
 
-[indexterm2 asio.indexterm.io_context__executor_type.post..post..io_context::executor_type] 
+[indexterm2 asio.indexterm.io_context__basic_executor_type.post..post..io_context::basic_executor_type] 
 Request the [link asio.reference.io_context `io_context`] to invoke the given function object. 
 
 
   template<
       typename Function,
-      typename Allocator>
+      typename OtherAllocator>
   void post(
       Function && f,
-      const Allocator & a) const;
+      const OtherAllocator & a) const;
 
 
 This function is used to ask the [link asio.reference.io_context `io_context`] to execute the given function object. The function object will never be executed inside `post()`. Instead, it will be scheduled to run on the [link asio.reference.io_context `io_context`].
@@ -71895,10 +79931,371 @@ This function is used to ask the [link asio.reference.io_context `io_context`] t
 [endsect]
 
 
+[section:query io_context::basic_executor_type::query]
 
-[section:running_in_this_thread io_context::executor_type::running_in_this_thread]
+[indexterm2 asio.indexterm.io_context__basic_executor_type.query..query..io_context::basic_executor_type] 
+Query the current value of the `context` property. 
 
-[indexterm2 asio.indexterm.io_context__executor_type.running_in_this_thread..running_in_this_thread..io_context::executor_type] 
+
+  io_context & ``[link asio.reference.io_context__basic_executor_type.query.overload1 query]``(
+      execution::context_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query.overload1 more...]]``
+
+
+Query the current value of the `blocking` property. 
+
+
+  constexpr execution::blocking_t ``[link asio.reference.io_context__basic_executor_type.query.overload2 query]``(
+      execution::blocking_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query.overload2 more...]]``
+
+
+Query the current value of the `relationship` property. 
+
+
+  constexpr execution::relationship_t ``[link asio.reference.io_context__basic_executor_type.query.overload3 query]``(
+      execution::relationship_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query.overload3 more...]]``
+
+
+Query the current value of the `allocator` property. 
+
+
+  template<
+      typename OtherAllocator>
+  constexpr Allocator ``[link asio.reference.io_context__basic_executor_type.query.overload4 query]``(
+      execution::allocator_t< OtherAllocator > ) const;
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query.overload4 more...]]``
+
+  constexpr Allocator ``[link asio.reference.io_context__basic_executor_type.query.overload5 query]``(
+      execution::allocator_t< void > ) const;
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query.overload5 more...]]``
+
+
+[section:overload1 io_context::basic_executor_type::query (1 of 5 overloads)]
+
+
+Query the current value of the `context` property. 
+
+
+  io_context & query(
+      execution::context_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 io_context::basic_executor_type::query (2 of 5 overloads)]
+
+
+Query the current value of the `blocking` property. 
+
+
+  constexpr execution::blocking_t query(
+      execution::blocking_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload3 io_context::basic_executor_type::query (3 of 5 overloads)]
+
+
+Query the current value of the `relationship` property. 
+
+
+  constexpr execution::relationship_t query(
+      execution::relationship_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload4 io_context::basic_executor_type::query (4 of 5 overloads)]
+
+
+Query the current value of the `allocator` property. 
+
+
+  template<
+      typename OtherAllocator>
+  constexpr Allocator query(
+      execution::allocator_t< OtherAllocator > ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload5 io_context::basic_executor_type::query (5 of 5 overloads)]
+
+
+Query the current value of the `allocator` property. 
+
+
+  constexpr Allocator query(
+      execution::allocator_t< void > ) const;
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:query__static io_context::basic_executor_type::query]
+
+[indexterm2 asio.indexterm.io_context__basic_executor_type.query__static..query..io_context::basic_executor_type] 
+Query the current value of the `mapping` property. 
+
+
+  static constexpr execution::mapping_t ``[link asio.reference.io_context__basic_executor_type.query__static.overload1 query]``(
+      execution::mapping_t );
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query__static.overload1 more...]]``
+
+
+Query the current value of the `outstanding_work` property. 
+
+
+  static constexpr execution::outstanding_work_t ``[link asio.reference.io_context__basic_executor_type.query__static.overload2 query]``(
+      execution::outstanding_work_t );
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query__static.overload2 more...]]``
+
+
+[section:overload1 io_context::basic_executor_type::query (1 of 2 overloads)]
+
+
+Query the current value of the `mapping` property. 
+
+
+  static constexpr execution::mapping_t query(
+      execution::mapping_t );
+
+
+
+[endsect]
+
+
+
+[section:overload2 io_context::basic_executor_type::query (2 of 2 overloads)]
+
+
+Query the current value of the `outstanding_work` property. 
+
+
+  static constexpr execution::outstanding_work_t query(
+      execution::outstanding_work_t );
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:require io_context::basic_executor_type::require]
+
+[indexterm2 asio.indexterm.io_context__basic_executor_type.require..require..io_context::basic_executor_type] 
+Obtain an executor with the `blocking.possibly` property. 
+
+
+  constexpr basic_executor_type ``[link asio.reference.io_context__basic_executor_type.require.overload1 require]``(
+      execution::blocking_t::possibly_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload1 more...]]``
+
+
+Obtain an executor with the `blocking.never` property. 
+
+
+  constexpr basic_executor_type ``[link asio.reference.io_context__basic_executor_type.require.overload2 require]``(
+      execution::blocking_t::never_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload2 more...]]``
+
+
+Obtain an executor with the `relationship.fork` property. 
+
+
+  constexpr basic_executor_type ``[link asio.reference.io_context__basic_executor_type.require.overload3 require]``(
+      execution::relationship_t::fork_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload3 more...]]``
+
+
+Obtain an executor with the `relationship.continuation` property. 
+
+
+  constexpr basic_executor_type ``[link asio.reference.io_context__basic_executor_type.require.overload4 require]``(
+      execution::relationship_t::continuation_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload4 more...]]``
+
+
+Obtain an executor with the `outstanding_work.tracked` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.io_context__basic_executor_type.require.overload5 require]``(
+      execution::outstanding_work_t::tracked_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload5 more...]]``
+
+
+Obtain an executor with the `outstanding_work.untracked` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.io_context__basic_executor_type.require.overload6 require]``(
+      execution::outstanding_work_t::untracked_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload6 more...]]``
+
+
+Obtain an executor with the specified `allocator` property. 
+
+
+  template<
+      typename OtherAllocator>
+  constexpr basic_executor_type< OtherAllocator, Bits > ``[link asio.reference.io_context__basic_executor_type.require.overload7 require]``(
+      execution::allocator_t< OtherAllocator > a) const;
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload7 more...]]``
+
+
+Obtain an executor with the default `allocator` property. 
+
+
+  constexpr basic_executor_type< std::allocator< void >, Bits > ``[link asio.reference.io_context__basic_executor_type.require.overload8 require]``(
+      execution::allocator_t< void > ) const;
+  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload8 more...]]``
+
+
+[section:overload1 io_context::basic_executor_type::require (1 of 8 overloads)]
+
+
+Obtain an executor with the `blocking.possibly` property. 
+
+
+  constexpr basic_executor_type require(
+      execution::blocking_t::possibly_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 io_context::basic_executor_type::require (2 of 8 overloads)]
+
+
+Obtain an executor with the `blocking.never` property. 
+
+
+  constexpr basic_executor_type require(
+      execution::blocking_t::never_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload3 io_context::basic_executor_type::require (3 of 8 overloads)]
+
+
+Obtain an executor with the `relationship.fork` property. 
+
+
+  constexpr basic_executor_type require(
+      execution::relationship_t::fork_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload4 io_context::basic_executor_type::require (4 of 8 overloads)]
+
+
+Obtain an executor with the `relationship.continuation` property. 
+
+
+  constexpr basic_executor_type require(
+      execution::relationship_t::continuation_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload5 io_context::basic_executor_type::require (5 of 8 overloads)]
+
+
+Obtain an executor with the `outstanding_work.tracked` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > require(
+      execution::outstanding_work_t::tracked_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload6 io_context::basic_executor_type::require (6 of 8 overloads)]
+
+
+Obtain an executor with the `outstanding_work.untracked` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > require(
+      execution::outstanding_work_t::untracked_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload7 io_context::basic_executor_type::require (7 of 8 overloads)]
+
+
+Obtain an executor with the specified `allocator` property. 
+
+
+  template<
+      typename OtherAllocator>
+  constexpr basic_executor_type< OtherAllocator, Bits > require(
+      execution::allocator_t< OtherAllocator > a) const;
+
+
+
+[endsect]
+
+
+
+[section:overload8 io_context::basic_executor_type::require (8 of 8 overloads)]
+
+
+Obtain an executor with the default `allocator` property. 
+
+
+  constexpr basic_executor_type< std::allocator< void >, Bits > require(
+      execution::allocator_t< void > ) const;
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:running_in_this_thread io_context::basic_executor_type::running_in_this_thread]
+
+[indexterm2 asio.indexterm.io_context__basic_executor_type.running_in_this_thread..running_in_this_thread..io_context::basic_executor_type] 
 Determine whether the [link asio.reference.io_context `io_context`] is running in the current thread. 
 
 
@@ -71913,6 +80310,20 @@ Determine whether the [link asio.reference.io_context `io_context`] is running i
 
 
 
+[endsect]
+
+
+
+[section:_basic_executor_type io_context::basic_executor_type::~basic_executor_type]
+
+[indexterm2 asio.indexterm.io_context__basic_executor_type._basic_executor_type..~basic_executor_type..io_context::basic_executor_type] 
+Destructor. 
+
+
+  ~basic_executor_type();
+
+
+
 [endsect]
 
 
@@ -72786,8 +81197,8 @@ Typedef for backwards compatibility.
 
   [
 
-    [[link asio.reference.io_context__executor_type [*executor_type]]]
-    [Executor used to submit functions to an io_context. ]
+    [[link asio.reference.io_context__basic_executor_type [*basic_executor_type]]]
+    [Executor implementation type used to submit functions to an io_context. ]
   
   ]
 
@@ -72819,6 +81230,13 @@ Typedef for backwards compatibility.
   
   ]
 
+  [
+
+    [[link asio.reference.io_context.executor_type [*executor_type]]]
+    [Executor used to submit functions to an io_context. ]
+  
+  ]
+
   [
 
     [[link asio.reference.io_context.fork_event [*fork_event]]]
@@ -73081,13 +81499,41 @@ For example:
   
 
 
-Some applications may need to prevent an [link asio.reference.io_context `io_context`] object's `run()` call from returning when there is no more work to do. For example, the [link asio.reference.io_context `io_context`] may be being run in a background thread that is launched prior to the application's asynchronous operations. The `run()` call may be kept running by creating an object of type asio::executor\_work\_guard<io\_context::executor\_type>:
+Some applications may need to prevent an [link asio.reference.io_context `io_context`] object's `run()` call from returning when there is no more work to do. For example, the [link asio.reference.io_context `io_context`] may be being run in a background thread that is launched prior to the application's asynchronous operations. The `run()` call may be kept running by creating an executor that tracks work against the [link asio.reference.io_context `io_context`]:
 
 
 
    asio::io_context io_context;
-   asio::executor_work_guard<asio::io_context::executor_type>
-     = asio::make_work_guard(io_context);
+   auto work = asio::require(io_context.get_executor(),
+       asio::execution::outstanding_work.tracked);
+   ... 
+
+
+
+
+If using C++03, which lacks automatic variable type deduction, you may compute the return type of the require call:
+
+
+
+   asio::io_context io_context;
+   typename asio::require_result_type<
+       asio::io_context::executor_type,
+       asio::exeution::outstanding_work_t::tracked_t>
+     work = asio::require(io_context.get_executor(),
+       asio::execution::outstanding_work.tracked);
+   ... 
+
+
+
+
+or store the result in the type-erasing executor wrapper, any\_io\_executor:
+
+
+
+   asio::io_context io_context;
+   asio::any_io_executor work
+     = asio::require(io_context.get_executor(),
+         asio::execution::outstanding_work.tracked);
    ... 
 
 
@@ -73095,15 +81541,16 @@ Some applications may need to prevent an [link asio.reference.io_context `io_con
 
 To effect a shutdown, the application will then need to call the [link asio.reference.io_context `io_context`] object's `stop()` member function. This will cause the [link asio.reference.io_context `io_context`] `run()` call to return as soon as possible, abandoning unfinished operations and without permitting ready handlers to be dispatched.
 
-Alternatively, if the application requires that all operations and handlers be allowed to finish normally, the work object may be explicitly reset.
+Alternatively, if the application requires that all operations and handlers be allowed to finish normally, store the work-tracking executor in an any\_io\_executor object, so that it may be explicitly reset.
 
 
 
    asio::io_context io_context;
-   asio::executor_work_guard<asio::io_context::executor_type>
-     = asio::make_work_guard(io_context);
+   asio::any_io_executor work
+     = asio::require(io_context.get_executor(),
+         asio::execution::outstanding_work.tracked);
    ...
-   work.reset(); // Allow run() to exit. 
+   work = asio::any_io_executor(); // Allow run() to exit. 
 
 
 
@@ -91247,6 +99694,26 @@ Getting the current option value:
 [endsect]
 
 
+[section:is_applicable_property is_applicable_property]
+
+
+
+  template<
+      typename T,
+      typename Property,
+      typename  = void>
+  struct is_applicable_property
+
+
+[heading Requirements]
+
+['Header: ][^asio/is_applicable_property.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
 [section:is_const_buffer_sequence is_const_buffer_sequence]
 
 
@@ -91459,6 +99926,98 @@ Trait to determine whether a type satisfies the MutableBufferSequence requiremen
 ['Convenience header: ][^asio.hpp]
 
 
+[endsect]
+
+[section:is_nothrow_prefer is_nothrow_prefer]
+
+
+A type trait that determines whether a `prefer` expression will not throw. 
+
+
+  template<
+      typename T,
+      typename... Properties>
+  struct is_nothrow_prefer
+
+
+Class template `is_nothrow_prefer` is a trait that is derived from `true_type` if the expression `asio::prefer(std::declval<T>(), std::declval<Properties>()...)` is `noexcept`; otherwise `false_type`. 
+
+[heading Requirements]
+
+['Header: ][^asio/prefer.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+[section:is_nothrow_query is_nothrow_query]
+
+
+A type trait that determines whether a `query` expression will not throw. 
+
+
+  template<
+      typename T,
+      typename Property>
+  struct is_nothrow_query
+
+
+Class template `is_nothrow_query` is a trait that is derived from `true_type` if the expression `asio::query(std::declval<T>(), std::declval<Property>())` is `noexcept`; otherwise `false_type`. 
+
+[heading Requirements]
+
+['Header: ][^asio/query.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+[section:is_nothrow_require is_nothrow_require]
+
+
+A type trait that determines whether a `require` expression will not throw. 
+
+
+  template<
+      typename T,
+      typename... Properties>
+  struct is_nothrow_require
+
+
+Class template `is_nothrow_require` is a trait that is derived from `true_type` if the expression `asio::require(std::declval<T>(), std::declval<Properties>()...)` is `noexcept`; otherwise `false_type`. 
+
+[heading Requirements]
+
+['Header: ][^asio/require.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+[section:is_nothrow_require_concept is_nothrow_require_concept]
+
+
+A type trait that determines whether a `require_concept` expression will not throw. 
+
+
+  template<
+      typename T,
+      typename Property>
+  struct is_nothrow_require_concept
+
+
+Class template `is_nothrow_require_concept` is a trait that is derived from `true_type` if the expression `asio::require_concept(std::declval<T>(), std::declval<Property>())` is `noexcept`; otherwise `false_type`. 
+
+[heading Requirements]
+
+['Header: ][^asio/require_concept.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
 [endsect]
 
 [section:is_read_buffered is_read_buffered]
@@ -94214,7 +102773,7 @@ Create a [link asio.reference.strand `strand`]  object for an executor.
       typename ``[link asio.reference.Executor1 Executor]``>
   strand< Executor > ``[link asio.reference.make_strand.overload1 make_strand]``(
       const Executor & ex,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.make_strand.overload1 more...]]``
 
 Create a [link asio.reference.strand `strand`]  object for an execution context. 
@@ -94243,7 +102802,7 @@ Create a [link asio.reference.strand `strand`]  object for an executor.
       typename ``[link asio.reference.Executor1 Executor]``>
   strand< Executor > make_strand(
       const Executor & ex,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
 
 
 
@@ -94279,7 +102838,7 @@ Create an [link asio.reference.executor_work_guard `executor_work_guard`]  objec
       typename ``[link asio.reference.Executor1 Executor]``>
   executor_work_guard< Executor > ``[link asio.reference.make_work_guard.overload1 make_work_guard]``(
       const Executor & ex,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.make_work_guard.overload1 more...]]``
 
   template<
@@ -94293,7 +102852,7 @@ Create an [link asio.reference.executor_work_guard `executor_work_guard`]  objec
       typename T>
   executor_work_guard< typename associated_executor< T >::type > ``[link asio.reference.make_work_guard.overload3 make_work_guard]``(
       const T & t,
-      typename enable_if<!is_executor< T >::value &&!is_convertible< T &, execution_context & >::value >::type *  = 0);
+      typename enable_if< !is_executor< T >::value &&!execution::is_executor< T >::value &&!is_convertible< T &, execution_context & >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.make_work_guard.overload3 more...]]``
 
   template<
@@ -94302,7 +102861,7 @@ Create an [link asio.reference.executor_work_guard `executor_work_guard`]  objec
   executor_work_guard< typename associated_executor< T, Executor >::type > ``[link asio.reference.make_work_guard.overload4 make_work_guard]``(
       const T & t,
       const Executor & ex,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.make_work_guard.overload4 more...]]``
 
   template<
@@ -94311,7 +102870,7 @@ Create an [link asio.reference.executor_work_guard `executor_work_guard`]  objec
   executor_work_guard< typename associated_executor< T, typename ExecutionContext::executor_type >::type > ``[link asio.reference.make_work_guard.overload5 make_work_guard]``(
       const T & t,
       ExecutionContext & ctx,
-      typename enable_if<!is_executor< T >::value &&!is_convertible< T &, execution_context & >::value &&is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
+      typename enable_if< !is_executor< T >::value &&!execution::is_executor< T >::value &&!is_convertible< T &, execution_context & >::value &&is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.make_work_guard.overload5 more...]]``
 
 [heading Requirements]
@@ -94331,7 +102890,7 @@ Create an [link asio.reference.executor_work_guard `executor_work_guard`]  objec
       typename ``[link asio.reference.Executor1 Executor]``>
   executor_work_guard< Executor > make_work_guard(
       const Executor & ex,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
 
 
 
@@ -94367,7 +102926,7 @@ Create an [link asio.reference.executor_work_guard `executor_work_guard`]  objec
       typename T>
   executor_work_guard< typename associated_executor< T >::type > make_work_guard(
       const T & t,
-      typename enable_if<!is_executor< T >::value &&!is_convertible< T &, execution_context & >::value >::type *  = 0);
+      typename enable_if< !is_executor< T >::value &&!execution::is_executor< T >::value &&!is_convertible< T &, execution_context & >::value >::type *  = 0);
 
 
 
@@ -94387,7 +102946,7 @@ Create an [link asio.reference.executor_work_guard `executor_work_guard`]  objec
   executor_work_guard< typename associated_executor< T, Executor >::type > make_work_guard(
       const T & t,
       const Executor & ex,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
 
 
 
@@ -94407,13 +102966,96 @@ Create an [link asio.reference.executor_work_guard `executor_work_guard`]  objec
   executor_work_guard< typename associated_executor< T, typename ExecutionContext::executor_type >::type > make_work_guard(
       const T & t,
       ExecutionContext & ctx,
-      typename enable_if<!is_executor< T >::value &&!is_convertible< T &, execution_context & >::value &&is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
+      typename enable_if< !is_executor< T >::value &&!execution::is_executor< T >::value &&!is_convertible< T &, execution_context & >::value &&is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
 
 
 
 [endsect]
 
 
+[endsect]
+
+[section:multiple_exceptions multiple_exceptions]
+
+
+Exception thrown when there are multiple pending exceptions to rethrow. 
+
+
+  class multiple_exceptions :
+    public std::exception
+
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.multiple_exceptions.first_exception [*first_exception]]]
+    [Obtain a pointer to the first exception. ]
+  ]
+  
+  [
+    [[link asio.reference.multiple_exceptions.multiple_exceptions [*multiple_exceptions]]]
+    [Constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.multiple_exceptions.what [*what]]]
+    [Obtain message associated with exception. ]
+  ]
+  
+]
+
+[heading Requirements]
+
+['Header: ][^asio/multiple_exceptions.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[section:first_exception multiple_exceptions::first_exception]
+
+[indexterm2 asio.indexterm.multiple_exceptions.first_exception..first_exception..multiple_exceptions] 
+Obtain a pointer to the first exception. 
+
+
+  std::exception_ptr first_exception() const;
+
+
+
+[endsect]
+
+
+
+[section:multiple_exceptions multiple_exceptions::multiple_exceptions]
+
+[indexterm2 asio.indexterm.multiple_exceptions.multiple_exceptions..multiple_exceptions..multiple_exceptions] 
+Constructor. 
+
+
+  multiple_exceptions(
+      std::exception_ptr first);
+
+
+
+[endsect]
+
+
+
+[section:what multiple_exceptions::what]
+
+[indexterm2 asio.indexterm.multiple_exceptions.what..what..multiple_exceptions] 
+Obtain message associated with exception. 
+
+
+  virtual const char * what() const;
+
+
+
+[endsect]
+
+
+
 [endsect]
 
 [section:mutable_buffer mutable_buffer]
@@ -95348,7 +103990,7 @@ Provides POSIX descriptor functionality.
 
 
   template<
-      typename ``[link asio.reference.Executor1 Executor]`` = executor>
+      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
   class basic_descriptor :
     public posix::descriptor_base
 
@@ -97242,7 +105884,7 @@ Provides stream-oriented descriptor functionality.
 
 
   template<
-      typename ``[link asio.reference.Executor1 Executor]`` = executor>
+      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
   class basic_stream_descriptor :
     public posix::basic_descriptor< Executor >
 
@@ -100302,7 +108944,7 @@ Submits a completion token or function object for execution.
   ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.post.overload2 post]``(
       const Executor & ex,
       CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< execution::is_executor< Executor >::value||is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.post.overload2 more...]]``
 
   template<
@@ -100376,7 +109018,7 @@ Submits a completion token or function object for execution.
   ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` post(
       const Executor & ex,
       CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< execution::is_executor< Executor >::value||is_executor< Executor >::value >::type *  = 0);
 
 
 This function submits an object for execution using the specified executor. The function object is queued for execution, and is never called from the current thread prior to returning from `post()`.
@@ -100442,6 +109084,210 @@ Submits a completion token or function object for execution.
 [endsect]
 
 
+[endsect]
+
+
+[section:prefer prefer]
+
+[indexterm1 asio.indexterm.prefer..prefer] 
+A customisation point that attempts to apply a property to an object. 
+
+
+  constexpr unspecified prefer = unspecified;
+
+
+The name `prefer` denotes a customisation point object. The expression `asio::prefer(E, P0, Pn...)` for some subexpressions `E` and `P0`, and where `Pn...` represents `N` subexpressions (where `N` is 0 or more, and with types `T = decay_t<decltype(E)>` and `Prop0 = decay_t<decltype(P0)>`) is expression-equivalent to:
+
+
+* If `is_applicable_property_v<T, Prop0> && Prop0::is_preferable` is not a well-formed constant expression with value `true`, `asio::prefer(E, P0, Pn...)` is ill-formed.
+
+
+* Otherwise, `E` if `N == 0` and the expression `Prop0::template static_query_v<T> == Prop0::value()` is a well-formed constant expression with value `true`.
+
+
+* Otherwise, `(E).require(P0)` if `N == 0` and the expression `(E).require(P0)` is a valid expression.
+
+
+* Otherwise, `require(E, P0)` if `N == 0` and the expression `require(E, P0)` is a valid expression with overload resolution performed in a context that does not include the declaration of the `require` customization point object.
+
+
+* Otherwise, `(E).prefer(P0)` if `N == 0` and the expression `(E).prefer(P0)` is a valid expression.
+
+
+* Otherwise, `prefer(E, P0)` if `N == 0` and the expression `prefer(E, P0)` is a valid expression with overload resolution performed in a context that does not include the declaration of the `prefer` customization point object.
+
+
+* Otherwise, `E` if `N == 0`.
+
+
+* Otherwise, `asio::prefer(asio::prefer(E, P0), Pn...)` if `N > 0` and the expression `asio::prefer(asio::prefer(E, P0), Pn...)` is a valid expression.
+
+
+* Otherwise, `asio::prefer(E, P0, Pn...)` is ill-formed. 
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/prefer.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+[section:prefer_result_type prefer_result_type]
+
+
+A type trait that determines the result type of a `prefer` expression. 
+
+
+  template<
+      typename T,
+      typename... Properties>
+  struct prefer_result_type
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.prefer_result_type.type [*type]]]
+    [The result of the prefer expression. ]
+  
+  ]
+
+]
+
+Class template `prefer_result_type` is a trait that determines the result type of the expression `asio::prefer(std::declval<T>(), std::declval<Properties>()...)`. 
+
+[heading Requirements]
+
+['Header: ][^asio/prefer.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[section:type prefer_result_type::type]
+
+[indexterm2 asio.indexterm.prefer_result_type.type..type..prefer_result_type] 
+The result of the `prefer` expression. 
+
+
+  typedef automatically_determined type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/prefer.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:query query]
+
+[indexterm1 asio.indexterm.query..query] 
+A customisation point that queries the value of a property. 
+
+
+  constexpr unspecified query = unspecified;
+
+
+The name `query` denotes a customization point object. The expression `asio::query(E, P)` for some subexpressions `E` and `P` (with types `T = decay_t<decltype(E)>` and `Prop = decay_t<decltype(P)>`) is expression-equivalent to:
+
+
+* If `is_applicable_property_v<T, Prop>` is not a well-formed constant expression with value `true`, `asio::query(E, P)` is ill-formed.
+
+
+* Otherwise, `Prop::template static_query_v<T>` if the expression `Prop::template static_query_v<T>` is a well-formed constant expression.
+
+
+* Otherwise, `(E).query(P)` if the expression `(E).query(P)` is well-formed.
+
+
+* Otherwise, `query(E, P)` if the expression `query(E, P)` is a valid expression with overload resolution performed in a context that does not include the declaration of the `query` customization point object.
+
+
+* Otherwise, `asio::query(E, P)` is ill-formed. 
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/query.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+[section:query_result_type query_result_type]
+
+
+A type trait that determines the result type of a `query` expression. 
+
+
+  template<
+      typename T,
+      typename Property>
+  struct query_result_type
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.query_result_type.type [*type]]]
+    [The result of the query expression. ]
+  
+  ]
+
+]
+
+Class template `query_result_type` is a trait that determines the result type of the expression `asio::query(std::declval<T>(), std::declval<Property>())`. 
+
+[heading Requirements]
+
+['Header: ][^asio/query.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[section:type query_result_type::type]
+
+[indexterm2 asio.indexterm.query_result_type.type..type..query_result_type] 
+The result of the `query` expression. 
+
+
+  typedef automatically_determined type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/query.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+
 [endsect]
 
 [section:read read]
@@ -102780,7 +111626,7 @@ After a successful read\_until operation, the dynamic buffer sequence may contai
 To read data into a `std::string` until a newline is encountered: 
 
    std::string data;
-   std::string n = asio::read_until(s,
+   std::size_t n = asio::read_until(s,
        asio::dynamic_buffer(data), '\n');
    std::string line = data.substr(0, n);
    data.erase(0, n); 
@@ -102926,7 +111772,7 @@ After a successful read\_until operation, the dynamic buffer sequence may contai
 To read data into a `std::string` until a CR-LF sequence is encountered: 
 
    std::string data;
-   std::string n = asio::read_until(s,
+   std::size_t n = asio::read_until(s,
        asio::dynamic_buffer(data), "\r\n");
    std::string line = data.substr(0, n);
    data.erase(0, n); 
@@ -103082,7 +111928,7 @@ After a successful read\_until operation, the dynamic buffer sequence may contai
 To read data into a `std::string` until a CR-LF sequence is encountered: 
 
    std::string data;
-   std::string n = asio::read_until(s,
+   std::size_t n = asio::read_until(s,
        asio::dynamic_buffer(data), boost::regex("\r\n"));
    std::string line = data.substr(0, n);
    data.erase(0, n); 
@@ -104108,7 +112954,7 @@ After a successful read\_until operation, the dynamic buffer sequence may contai
 To read data into a `std::string` until a newline is encountered: 
 
    std::string data;
-   std::string n = asio::read_until(s,
+   std::size_t n = asio::read_until(s,
        asio::dynamic_buffer(data), '\n');
    std::string line = data.substr(0, n);
    data.erase(0, n); 
@@ -104254,7 +113100,7 @@ After a successful read\_until operation, the dynamic buffer sequence may contai
 To read data into a `std::string` until a CR-LF sequence is encountered: 
 
    std::string data;
-   std::string n = asio::read_until(s,
+   std::size_t n = asio::read_until(s,
        asio::dynamic_buffer(data), "\r\n");
    std::string line = data.substr(0, n);
    data.erase(0, n); 
@@ -104410,7 +113256,7 @@ After a successful read\_until operation, the dynamic buffer sequence may contai
 To read data into a `std::string` until a CR-LF sequence is encountered: 
 
    std::string data;
-   std::string n = asio::read_until(s,
+   std::size_t n = asio::read_until(s,
        asio::dynamic_buffer(data), boost::regex("\r\n"));
    std::string line = data.substr(0, n);
    data.erase(0, n); 
@@ -104818,6 +113664,201 @@ Constructor.
 
 
 
+[endsect]
+
+
+[section:require require]
+
+[indexterm1 asio.indexterm.require..require] 
+A customisation point that applies a concept-preserving property to an object. 
+
+
+  constexpr unspecified require = unspecified;
+
+
+The name `require` denotes a customisation point object. The expression `asio::require(E, P0, Pn...)` for some subexpressions `E` and `P0`, and where `Pn...` represents `N` subexpressions (where `N` is 0 or more, and with types `T = decay_t<decltype(E)>` and `Prop0 = decay_t<decltype(P0)>`) is expression-equivalent to:
+
+
+* If `is_applicable_property_v<T, Prop0> && Prop0::is_requirable` is not a well-formed constant expression with value `true`, `asio::require(E, P0, Pn...)` is ill-formed.
+
+
+* Otherwise, `E` if `N == 0` and the expression `Prop0::template static_query_v<T> == Prop0::value()` is a well-formed constant expression with value `true`.
+
+
+* Otherwise, `(E).require(P0)` if `N == 0` and the expression `(E).require(P0)` is a valid expression.
+
+
+* Otherwise, `require(E, P0)` if `N == 0` and the expression `require(E, P0)` is a valid expression with overload resolution performed in a context that does not include the declaration of the `require` customization point object.
+
+
+* Otherwise, `asio::require(asio::require(E, P0), Pn...)` if `N > 0` and the expression `asio::require(asio::require(E, P0), Pn...)` is a valid expression.
+
+
+* Otherwise, `asio::require(E, P0, Pn...)` is ill-formed. 
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/require.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+
+[section:require_concept require_concept]
+
+[indexterm1 asio.indexterm.require_concept..require_concept] 
+A customisation point that applies a concept-enforcing property to an object. 
+
+
+  constexpr unspecified require_concept = unspecified;
+
+
+The name `require_concept` denotes a customization point object. The expression `asio::require_concept(E, P)` for some subexpressions `E` and `P` (with types `T = decay_t<decltype(E)>` and `Prop = decay_t<decltype(P)>`) is expression-equivalent to:
+
+
+* If `is_applicable_property_v<T, Prop> && Prop::is_requirable_concept` is not a well-formed constant expression with value `true`, `asio::require_concept(E, P)` is ill-formed.
+
+
+* Otherwise, `E` if the expression `Prop::template static_query_v<T> == Prop::value()` is a well-formed constant expression with value `true`.
+
+
+* Otherwise, `(E).require_concept(P)` if the expression `(E).require_concept(P)` is well-formed.
+
+
+* Otherwise, `require_concept(E, P)` if the expression `require_concept(E, P)` is a valid expression with overload resolution performed in a context that does not include the declaration of the `require_concept` customization point object.
+
+
+* Otherwise, `asio::require_concept(E, P)` is ill-formed. 
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/require_concept.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+[section:require_concept_result_type require_concept_result_type]
+
+
+A type trait that determines the result type of a `require_concept` expression. 
+
+
+  template<
+      typename T,
+      typename Property>
+  struct require_concept_result_type
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.require_concept_result_type.type [*type]]]
+    [The result of the require_concept expression. ]
+  
+  ]
+
+]
+
+Class template `require_concept_result_type` is a trait that determines the result type of the expression `asio::require_concept(std::declval<T>(), std::declval<Property>())`. 
+
+[heading Requirements]
+
+['Header: ][^asio/require_concept.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[section:type require_concept_result_type::type]
+
+[indexterm2 asio.indexterm.require_concept_result_type.type..type..require_concept_result_type] 
+The result of the `require_concept` expression. 
+
+
+  typedef automatically_determined type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/require_concept.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:require_result_type require_result_type]
+
+
+A type trait that determines the result type of a `require` expression. 
+
+
+  template<
+      typename T,
+      typename... Properties>
+  struct require_result_type
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.require_result_type.type [*type]]]
+    [The result of the require expression. ]
+  
+  ]
+
+]
+
+Class template `require_result_type` is a trait that determines the result type of the expression `asio::require(std::declval<T>(), std::declval<Properties>()...)`. 
+
+[heading Requirements]
+
+['Header: ][^asio/require.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[section:type require_result_type::type]
+
+[indexterm2 asio.indexterm.require_result_type.type..type..require_result_type] 
+The result of the `require` expression. 
+
+
+  typedef automatically_determined type;
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/require.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+
 [endsect]
 
 
@@ -105758,7 +114799,7 @@ Exception thrown when trying to add a duplicate service to an [link asio.referen
 
 ['Header: ][^asio/execution_context.hpp]
 
-['Convenience header: ][^asio.hpp]
+['Convenience header: ][^asio/execution.hpp]
 
 
 [section:service_already_exists service_already_exists::service_already_exists]
@@ -106983,7 +116024,7 @@ Start a new stackful coroutine, calling the specified handler when it completes.
       Handler && handler,
       Function && function,
       const boost::coroutines::attributes & attributes = boost::coroutines::attributes(),
-      typename enable_if<!is_executor< typename decay< Handler >::type >::value &&!is_convertible< Handler &, execution_context & >::value >::type *  = 0);
+      typename enable_if< !is_executor< typename decay< Handler >::type >::value &&!execution::is_executor< typename decay< Handler >::type >::value &&!is_convertible< Handler &, execution_context & >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.spawn.overload2 more...]]``
 
 Start a new stackful coroutine, inheriting the execution context of another. 
@@ -107006,7 +116047,7 @@ Start a new stackful coroutine that executes on a given executor.
       const Executor & ex,
       Function && function,
       const boost::coroutines::attributes & attributes = boost::coroutines::attributes(),
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.spawn.overload4 more...]]``
 
 Start a new stackful coroutine that executes on a given strand. 
@@ -107132,7 +116173,7 @@ Start a new stackful coroutine, calling the specified handler when it completes.
       Handler && handler,
       Function && function,
       const boost::coroutines::attributes & attributes = boost::coroutines::attributes(),
-      typename enable_if<!is_executor< typename decay< Handler >::type >::value &&!is_convertible< Handler &, execution_context & >::value >::type *  = 0);
+      typename enable_if< !is_executor< typename decay< Handler >::type >::value &&!execution::is_executor< typename decay< Handler >::type >::value &&!is_convertible< Handler &, execution_context & >::value >::type *  = 0);
 
 
 This function is used to launch a new coroutine.
@@ -107221,7 +116262,7 @@ Start a new stackful coroutine that executes on a given executor.
       const Executor & ex,
       Function && function,
       const boost::coroutines::attributes & attributes = boost::coroutines::attributes(),
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< is_executor< Executor >::value||execution::is_executor< Executor >::value >::type *  = 0);
 
 
 This function is used to launch a new coroutine.
@@ -111217,7 +120258,9 @@ Provides stream-oriented functionality using SSL.
   
   [
     [[link asio.reference.ssl__stream.stream [*stream]]]
-    [Construct a stream. ]
+    [Construct a stream. 
+     [hr]
+     Move-construct a stream from another. ]
   ]
   
   [
@@ -112487,10 +121530,31 @@ This function is used to shut down SSL on the stream. The function call will blo
 
 [endsect]
 
-
 [section:stream ssl::stream::stream]
 
 [indexterm2 asio.indexterm.ssl__stream.stream..stream..ssl::stream] 
+Construct a stream. 
+
+
+  template<
+      typename Arg>
+  ``[link asio.reference.ssl__stream.stream.overload1 stream]``(
+      Arg && arg,
+      context & ctx);
+  ``  [''''&raquo;''' [link asio.reference.ssl__stream.stream.overload1 more...]]``
+
+
+Move-construct a stream from another. 
+
+
+  ``[link asio.reference.ssl__stream.stream.overload2 stream]``(
+      stream && other);
+  ``  [''''&raquo;''' [link asio.reference.ssl__stream.stream.overload2 more...]]``
+
+
+[section:overload1 ssl::stream::stream (1 of 2 overloads)]
+
+
 Construct a stream. 
 
 
@@ -112521,6 +121585,35 @@ This constructor creates a stream and initialises the underlying stream object.
 [endsect]
 
 
+
+[section:overload2 ssl::stream::stream (2 of 2 overloads)]
+
+
+Move-construct a stream from another. 
+
+
+  stream(
+      stream && other);
+
+
+
+[heading Parameters]
+    
+
+[variablelist
+  
+[[other][The other stream object from which the move will occur. Must have no outstanding asynchronous operations associated with it. Following the move, `other` has a valid but unspecified state where the only safe operation is destruction. ]]
+
+]
+
+
+
+
+[endsect]
+
+
+[endsect]
+
 [section:write_some ssl::stream::write_some]
 
 [indexterm2 asio.indexterm.ssl__stream.write_some..write_some..ssl::stream] 
@@ -113012,6 +122105,186 @@ Verify the peer.
 
 
 
+[section:static_thread_pool static_thread_pool]
+
+[indexterm1 asio.indexterm.static_thread_pool..static_thread_pool] 
+
+  typedef thread_pool static_thread_pool;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link asio.reference.thread_pool__basic_executor_type [*basic_executor_type]]]
+    [Executor implementation type used to submit functions to a thread pool. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.thread_pool.executor_type [*executor_type]]]
+    [Executor used to submit functions to a thread pool. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.thread_pool.fork_event [*fork_event]]]
+    [Fork-related event notifications. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.thread_pool.attach [*attach]]]
+    [Attaches the current thread to the pool. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool.executor [*executor]]]
+    [Obtains the executor associated with the pool. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool.get_executor [*get_executor]]]
+    [Obtains the executor associated with the pool. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool.join [*join]]]
+    [Joins the threads. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool.notify_fork [*notify_fork]]]
+    [Notify the execution_context of a fork-related event. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool.stop [*stop]]]
+    [Stops the threads. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool.thread_pool [*thread_pool]]]
+    [Constructs a pool with an automatically determined number of threads. 
+     [hr]
+     Constructs a pool with a specified number of threads. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool.wait [*wait]]]
+    [Waits for threads to complete. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool._thread_pool [*~thread_pool]]]
+    [Destructor. ]
+  ]
+  
+]
+
+[heading Protected Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.thread_pool.destroy [*destroy]]]
+    [Destroys all services in the context. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool.shutdown [*shutdown]]]
+    [Shuts down all services in the context. ]
+  ]
+  
+]
+
+[heading Friends]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.thread_pool.add_service [*add_service]]]
+    [(Deprecated: Use make_service().) Add a service object to the execution_context. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool.has_service [*has_service]]]
+    [Determine if an execution_context contains a specified service type. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool.make_service [*make_service]]]
+    [Creates a service object and adds it to the execution_context. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool.use_service [*use_service]]]
+    [Obtain the service object corresponding to the given type. ]
+  ]
+  
+]
+
+The thread pool class is an execution context where functions are permitted to run on one of a fixed number of threads.
+
+
+[heading Submitting tasks to the pool]
+  
+
+
+To submit functions to the thread pool, use the [link asio.reference.dispatch `dispatch`] , [link asio.reference.post `post`]  or [link asio.reference.defer `defer`]  free functions.
+
+For example:
+
+
+
+   void my_task()
+   {
+     ...
+   }
+
+   ...
+
+   // Launch the pool with four threads.
+   asio::thread_pool pool(4);
+
+   // Submit a function to the pool.
+   asio::post(pool, my_task);
+
+   // Submit a lambda object to the pool.
+   asio::post(pool,
+       []()
+       {
+         ...
+       });
+
+   // Wait for all tasks in the pool to complete.
+   pool.join(); 
+
+
+
+
+
+[heading Requirements]
+
+['Header: ][^asio/static_thread_pool.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+
 [section:steady_timer steady_timer]
 
 [indexterm1 asio.indexterm.steady_timer..steady_timer] 
@@ -113296,11 +122569,6 @@ Provides serialised function invocation for any executor type.
 [table
   [[Name][Description]]
 
-  [
-    [[link asio.reference.strand.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
   [
     [[link asio.reference.strand.defer [*defer]]]
     [Request the strand to invoke the given function object. ]
@@ -113311,21 +122579,16 @@ Provides serialised function invocation for any executor type.
     [Request the strand to invoke the given function object. ]
   ]
   
+  [
+    [[link asio.reference.strand.execute [*execute]]]
+    []
+  ]
+  
   [
     [[link asio.reference.strand.get_inner_executor [*get_inner_executor]]]
     [Obtain the underlying executor. ]
   ]
   
-  [
-    [[link asio.reference.strand.on_work_finished [*on_work_finished]]]
-    [Inform the strand that some work is no longer outstanding. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.on_work_started [*on_work_started]]]
-    [Inform the strand that it has some outstanding work to do. ]
-  ]
-  
   [
     [[link asio.reference.strand.operator_eq_ [*operator=]]]
     [Assignment operator. 
@@ -113342,6 +122605,21 @@ Provides serialised function invocation for any executor type.
     [Request the strand to invoke the given function object. ]
   ]
   
+  [
+    [[link asio.reference.strand.prefer [*prefer]]]
+    []
+  ]
+  
+  [
+    [[link asio.reference.strand.query [*query]]]
+    [Forward a query to the underlying executor. ]
+  ]
+  
+  [
+    [[link asio.reference.strand.require [*require]]]
+    []
+  ]
+  
   [
     [[link asio.reference.strand.running_in_this_thread [*running_in_this_thread]]]
     [Determine whether the strand is running in the current thread. ]
@@ -113392,20 +122670,6 @@ Provides serialised function invocation for any executor type.
 ['Convenience header: ][^asio.hpp]
 
 
-[section:context strand::context]
-
-[indexterm2 asio.indexterm.strand.context..context..strand] 
-Obtain the underlying execution context. 
-
-
-  execution_context & context() const;
-
-
-
-[endsect]
-
-
-
 [section:defer strand::defer]
 
 [indexterm2 asio.indexterm.strand.defer..defer..strand] 
@@ -113480,6 +122744,19 @@ This function is used to ask the strand to execute the given function object on
 
 
 
+[endsect]
+
+
+
+[section:execute strand::execute]
+
+[indexterm2 asio.indexterm.strand.execute..execute..strand] 
+
+  Function::value::type execute(
+      Function && f) const;
+
+
+
 [endsect]
 
 
@@ -113519,38 +122796,6 @@ The type of the underlying executor.
 
 
 
-[section:on_work_finished strand::on_work_finished]
-
-[indexterm2 asio.indexterm.strand.on_work_finished..on_work_finished..strand] 
-Inform the strand that some work is no longer outstanding. 
-
-
-  void on_work_finished() const;
-
-
-The strand delegates this call to its underlying executor. 
-
-
-[endsect]
-
-
-
-[section:on_work_started strand::on_work_started]
-
-[indexterm2 asio.indexterm.strand.on_work_started..on_work_started..strand] 
-Inform the strand that it has some outstanding work to do. 
-
-
-  void on_work_started() const;
-
-
-The strand delegates this call to its underlying executor. 
-
-
-[endsect]
-
-
-
 [section:operator_not__eq_ strand::operator!=]
 
 [indexterm2 asio.indexterm.strand.operator_not__eq_..operator!=..strand] 
@@ -113742,6 +122987,49 @@ This function is used to ask the executor to execute the given function object.
 
 
 
+[endsect]
+
+
+
+[section:prefer strand::prefer]
+
+[indexterm2 asio.indexterm.strand.prefer..prefer..strand] 
+
+  Property strand< typename decay< typename prefer_result_type< const Executor &, Property >::type >::type >::type prefer(
+      const Property & p) const;
+
+
+
+[endsect]
+
+
+
+[section:query strand::query]
+
+[indexterm2 asio.indexterm.strand.query..query..strand] 
+Forward a query to the underlying executor. 
+
+
+  template<
+      typename Property>
+  enable_if< can_query< const Executor &, Property >::value, typename query_result_type< const Executor &, Property >::type >::type query(
+      const Property & p) const;
+
+
+
+[endsect]
+
+
+
+[section:require strand::require]
+
+[indexterm2 asio.indexterm.strand.require..require..strand] 
+
+  Property strand< typename decay< typename require_result_type< const Executor &, Property >::type >::type >::type require(
+      const Property & p) const;
+
+
+
 [endsect]
 
 
@@ -114327,7 +123615,7 @@ This function is implemented as follows:
 The executor type associated with the context. 
 
 
-  typedef system_executor executor_type;
+  typedef basic_system_executor< execution::blocking_t::possibly_t, execution::relationship_t::fork_t, std::allocator< void > > executor_type;
 
 
 [heading Member Functions]
@@ -114335,35 +123623,80 @@ The executor type associated with the context.
   [[Name][Description]]
 
   [
-    [[link asio.reference.system_executor.context [*context]]]
+    [[link asio.reference.basic_system_executor.basic_system_executor [*basic_system_executor]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.context [*context]]]
     [Obtain the underlying execution context. ]
   ]
   
   [
-    [[link asio.reference.system_executor.defer [*defer]]]
+    [[link asio.reference.basic_system_executor.defer [*defer]]]
     [Request the system executor to invoke the given function object. ]
   ]
   
   [
-    [[link asio.reference.system_executor.dispatch [*dispatch]]]
+    [[link asio.reference.basic_system_executor.dispatch [*dispatch]]]
     [Request the system executor to invoke the given function object. ]
   ]
   
   [
-    [[link asio.reference.system_executor.on_work_finished [*on_work_finished]]]
+    [[link asio.reference.basic_system_executor.execute [*execute]]]
+    [Oneway execution function. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.on_work_finished [*on_work_finished]]]
     [Inform the executor that some work is no longer outstanding. ]
   ]
   
   [
-    [[link asio.reference.system_executor.on_work_started [*on_work_started]]]
+    [[link asio.reference.basic_system_executor.on_work_started [*on_work_started]]]
     [Inform the executor that it has some outstanding work to do. ]
   ]
   
   [
-    [[link asio.reference.system_executor.post [*post]]]
+    [[link asio.reference.basic_system_executor.post [*post]]]
     [Request the system executor to invoke the given function object. ]
   ]
   
+  [
+    [[link asio.reference.basic_system_executor.query [*query]]]
+    [Query the current value of the allocator property. 
+     [hr]
+     Query the occupancy (recommended number of work items) for the system context. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.query__static [*query]]]
+    [Query the current value of the mapping property. 
+     [hr]
+     Query the current value of the context property. 
+     [hr]
+     Query the current value of the blocking property. 
+     [hr]
+     Query the current value of the relationship property. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.require [*require]]]
+    [Obtain an executor with the blocking.possibly property. 
+     [hr]
+     Obtain an executor with the blocking.always property. 
+     [hr]
+     Obtain an executor with the blocking.never property. 
+     [hr]
+     Obtain an executor with the relationship.continuation property. 
+     [hr]
+     Obtain an executor with the relationship.fork property. 
+     [hr]
+     Obtain an executor with the specified allocator property. 
+     [hr]
+     Obtain an executor with the default allocator property. ]
+  ]
+  
 ]
 
 [heading Friends]
@@ -114371,18 +123704,18 @@ The executor type associated with the context.
   [[Name][Description]]
 
   [
-    [[link asio.reference.system_executor.operator_not__eq_ [*operator!=]]]
+    [[link asio.reference.basic_system_executor.operator_not__eq_ [*operator!=]]]
     [Compare two executors for inequality. ]
   ]
   
   [
-    [[link asio.reference.system_executor.operator_eq__eq_ [*operator==]]]
+    [[link asio.reference.basic_system_executor.operator_eq__eq_ [*operator==]]]
     [Compare two executors for equality. ]
   ]
   
 ]
 
-The system executor represents an execution context where functions are permitted to run on arbitrary threads. The `post()` and `defer()` functions schedule the function to run on an unspecified system thread pool, and `dispatch()` invokes the function immediately. 
+The system executor represents an execution context where functions are permitted to run on arbitrary threads. When the blocking.never property is established, the system executor will schedule the function to run on an unspecified system thread pool. When either blocking.possibly or blocking.always is established, the executor invokes the function immediately. 
 
 
 [heading Requirements]
@@ -115002,13 +124335,14 @@ Destructor.
 
 [endsect]
 
+
 [section:system_executor system_executor]
 
-
+[indexterm1 asio.indexterm.system_executor..system_executor] 
 An executor that uses arbitrary threads. 
 
 
-  class system_executor
+  typedef basic_system_executor< execution::blocking_t::possibly_t, execution::relationship_t::fork_t, std::allocator< void > > system_executor;
 
 
 [heading Member Functions]
@@ -115016,35 +124350,80 @@ An executor that uses arbitrary threads.
   [[Name][Description]]
 
   [
-    [[link asio.reference.system_executor.context [*context]]]
+    [[link asio.reference.basic_system_executor.basic_system_executor [*basic_system_executor]]]
+    [Default constructor. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.context [*context]]]
     [Obtain the underlying execution context. ]
   ]
   
   [
-    [[link asio.reference.system_executor.defer [*defer]]]
+    [[link asio.reference.basic_system_executor.defer [*defer]]]
     [Request the system executor to invoke the given function object. ]
   ]
   
   [
-    [[link asio.reference.system_executor.dispatch [*dispatch]]]
+    [[link asio.reference.basic_system_executor.dispatch [*dispatch]]]
     [Request the system executor to invoke the given function object. ]
   ]
   
   [
-    [[link asio.reference.system_executor.on_work_finished [*on_work_finished]]]
+    [[link asio.reference.basic_system_executor.execute [*execute]]]
+    [Oneway execution function. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.on_work_finished [*on_work_finished]]]
     [Inform the executor that some work is no longer outstanding. ]
   ]
   
   [
-    [[link asio.reference.system_executor.on_work_started [*on_work_started]]]
+    [[link asio.reference.basic_system_executor.on_work_started [*on_work_started]]]
     [Inform the executor that it has some outstanding work to do. ]
   ]
   
   [
-    [[link asio.reference.system_executor.post [*post]]]
+    [[link asio.reference.basic_system_executor.post [*post]]]
     [Request the system executor to invoke the given function object. ]
   ]
   
+  [
+    [[link asio.reference.basic_system_executor.query [*query]]]
+    [Query the current value of the allocator property. 
+     [hr]
+     Query the occupancy (recommended number of work items) for the system context. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.query__static [*query]]]
+    [Query the current value of the mapping property. 
+     [hr]
+     Query the current value of the context property. 
+     [hr]
+     Query the current value of the blocking property. 
+     [hr]
+     Query the current value of the relationship property. ]
+  ]
+  
+  [
+    [[link asio.reference.basic_system_executor.require [*require]]]
+    [Obtain an executor with the blocking.possibly property. 
+     [hr]
+     Obtain an executor with the blocking.always property. 
+     [hr]
+     Obtain an executor with the blocking.never property. 
+     [hr]
+     Obtain an executor with the relationship.continuation property. 
+     [hr]
+     Obtain an executor with the relationship.fork property. 
+     [hr]
+     Obtain an executor with the specified allocator property. 
+     [hr]
+     Obtain an executor with the default allocator property. ]
+  ]
+  
 ]
 
 [heading Friends]
@@ -115052,162 +124431,21 @@ An executor that uses arbitrary threads.
   [[Name][Description]]
 
   [
-    [[link asio.reference.system_executor.operator_not__eq_ [*operator!=]]]
+    [[link asio.reference.basic_system_executor.operator_not__eq_ [*operator!=]]]
     [Compare two executors for inequality. ]
   ]
   
   [
-    [[link asio.reference.system_executor.operator_eq__eq_ [*operator==]]]
+    [[link asio.reference.basic_system_executor.operator_eq__eq_ [*operator==]]]
     [Compare two executors for equality. ]
   ]
   
 ]
 
-The system executor represents an execution context where functions are permitted to run on arbitrary threads. The `post()` and `defer()` functions schedule the function to run on an unspecified system thread pool, and `dispatch()` invokes the function immediately. 
+The system executor represents an execution context where functions are permitted to run on arbitrary threads. When the blocking.never property is established, the system executor will schedule the function to run on an unspecified system thread pool. When either blocking.possibly or blocking.always is established, the executor invokes the function immediately. 
 
-[heading Requirements]
 
-['Header: ][^asio/system_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:context system_executor::context]
-
-[indexterm2 asio.indexterm.system_executor.context..context..system_executor] 
-Obtain the underlying execution context. 
-
-
-  system_context & context() const;
-
-
-
-[endsect]
-
-
-
-[section:defer system_executor::defer]
-
-[indexterm2 asio.indexterm.system_executor.defer..defer..system_executor] 
-Request the system executor to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void defer(
-      Function && f,
-      const Allocator & a) const;
-
-
-This function is used to ask the executor to execute the given function object. The function object will never be executed inside this function. Instead, it will be scheduled to run on an unspecified system thread pool.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be:
-``
-   void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:dispatch system_executor::dispatch]
-
-[indexterm2 asio.indexterm.system_executor.dispatch..dispatch..system_executor] 
-Request the system executor to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void dispatch(
-      Function && f,
-      const Allocator & a) const;
-
-
-This function is used to ask the executor to execute the given function object. The function object will always be executed inside this function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be:
-``
-   void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:on_work_finished system_executor::on_work_finished]
-
-[indexterm2 asio.indexterm.system_executor.on_work_finished..on_work_finished..system_executor] 
-Inform the executor that some work is no longer outstanding. 
-
-
-  void on_work_finished() const;
-
-
-For the system executor, this is a no-op. 
-
-
-[endsect]
-
-
-
-[section:on_work_started system_executor::on_work_started]
-
-[indexterm2 asio.indexterm.system_executor.on_work_started..on_work_started..system_executor] 
-Inform the executor that it has some outstanding work to do. 
-
-
-  void on_work_started() const;
-
-
-For the system executor, this is a no-op. 
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ system_executor::operator!=]
-
-[indexterm2 asio.indexterm.system_executor.operator_not__eq_..operator!=..system_executor] 
-Compare two executors for inequality. 
-
-
-  friend bool operator!=(
-      const system_executor & ,
-      const system_executor & );
-
-
-System executors always compare equal. 
+The system executor represents an execution context where functions are permitted to run on arbitrary threads. When the blocking.never property is established, the system executor will schedule the function to run on an unspecified system thread pool. When either blocking.possibly or blocking.always is established, the executor invokes the function immediately. 
 
 [heading Requirements]
 
@@ -115220,72 +124458,6 @@ System executors always compare equal.
 
 
 
-[section:operator_eq__eq_ system_executor::operator==]
-
-[indexterm2 asio.indexterm.system_executor.operator_eq__eq_..operator==..system_executor] 
-Compare two executors for equality. 
-
-
-  friend bool operator==(
-      const system_executor & ,
-      const system_executor & );
-
-
-System executors always compare equal. 
-
-[heading Requirements]
-
-['Header: ][^asio/system_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:post system_executor::post]
-
-[indexterm2 asio.indexterm.system_executor.post..post..system_executor] 
-Request the system executor to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void post(
-      Function && f,
-      const Allocator & a) const;
-
-
-This function is used to ask the executor to execute the given function object. The function object will never be executed inside this function. Instead, it will be scheduled to run on an unspecified system thread pool.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be:
-``
-   void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
 [section:system_timer system_timer]
 
 [indexterm1 asio.indexterm.system_timer..system_timer] 
@@ -115754,7 +124926,14 @@ A simple fixed-size thread pool.
 
   [
 
-    [[link asio.reference.thread_pool__executor_type [*executor_type]]]
+    [[link asio.reference.thread_pool__basic_executor_type [*basic_executor_type]]]
+    [Executor implementation type used to submit functions to a thread pool. ]
+  
+  ]
+
+  [
+
+    [[link asio.reference.thread_pool.executor_type [*executor_type]]]
     [Executor used to submit functions to a thread pool. ]
   
   ]
@@ -115772,6 +124951,16 @@ A simple fixed-size thread pool.
 [table
   [[Name][Description]]
 
+  [
+    [[link asio.reference.thread_pool.attach [*attach]]]
+    [Attaches the current thread to the pool. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool.executor [*executor]]]
+    [Obtains the executor associated with the pool. ]
+  ]
+  
   [
     [[link asio.reference.thread_pool.get_executor [*get_executor]]]
     [Obtains the executor associated with the pool. ]
@@ -115799,6 +124988,11 @@ A simple fixed-size thread pool.
      Constructs a pool with a specified number of threads. ]
   ]
   
+  [
+    [[link asio.reference.thread_pool.wait [*wait]]]
+    [Waits for threads to complete. ]
+  ]
+  
   [
     [[link asio.reference.thread_pool._thread_pool [*~thread_pool]]]
     [Destructor. ]
@@ -115855,7 +125049,7 @@ The thread pool class is an execution context where functions are permitted to r
   
 
 
-To submit functions to the [link asio.reference.thread_pool `thread_pool`], use the [link asio.reference.dispatch `dispatch`] , [link asio.reference.post `post`]  or [link asio.reference.defer `defer`]  free functions.
+To submit functions to the thread pool, use the [link asio.reference.dispatch `dispatch`] , [link asio.reference.post `post`]  or [link asio.reference.defer `defer`]  free functions.
 
 For example:
 
@@ -115953,6 +125147,22 @@ This function is used to add a service to the [link asio.reference.execution_con
 
 
 
+[section:attach thread_pool::attach]
+
+[indexterm2 asio.indexterm.thread_pool.attach..attach..thread_pool] 
+Attaches the current thread to the pool. 
+
+
+  void attach();
+
+
+This function attaches the current thread to the pool so that it may be used for executing submitted function objects. Blocks the calling thread until the pool is stopped or joined and has no outstanding work. 
+
+
+[endsect]
+
+
+
 [section:destroy thread_pool::destroy]
 
 
@@ -115977,6 +125187,165 @@ This function is implemented as follows:
 
 
 
+[section:executor thread_pool::executor]
+
+[indexterm2 asio.indexterm.thread_pool.executor..executor..thread_pool] 
+Obtains the executor associated with the pool. 
+
+
+  executor_type executor();
+
+
+
+[endsect]
+
+
+
+[section:executor_type thread_pool::executor_type]
+
+[indexterm2 asio.indexterm.thread_pool.executor_type..executor_type..thread_pool] 
+Executor used to submit functions to a thread pool. 
+
+
+  typedef basic_executor_type< std::allocator< void >, 0 > executor_type;
+
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.basic_executor_type [*basic_executor_type]]]
+    [Copy construtor. 
+     [hr]
+     Move construtor. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.context [*context]]]
+    [Obtain the underlying execution context. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.defer [*defer]]]
+    [Request the thread pool to invoke the given function object. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.dispatch [*dispatch]]]
+    [Request the thread pool to invoke the given function object. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.execute [*execute]]]
+    [Execution function. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.on_work_finished [*on_work_finished]]]
+    [Inform the thread pool that some work is no longer outstanding. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.on_work_started [*on_work_started]]]
+    [Inform the thread pool that it has some outstanding work to do. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.operator_eq_ [*operator=]]]
+    [Assignment operator. 
+     [hr]
+     Move assignment operator. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.post [*post]]]
+    [Request the thread pool to invoke the given function object. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.query [*query]]]
+    [Query the current value of the context property. 
+     [hr]
+     Query the current value of the blocking property. 
+     [hr]
+     Query the current value of the relationship property. 
+     [hr]
+     Query the current value of the allocator property. 
+     [hr]
+     Query the occupancy (recommended number of work items) for the pool. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.query__static [*query]]]
+    [Query the current value of the bulk_guarantee property. 
+     [hr]
+     Query the current value of the mapping property. 
+     [hr]
+     Query the current value of the outstanding_work property. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.require [*require]]]
+    [Obtain an executor with the blocking.possibly property. 
+     [hr]
+     Obtain an executor with the blocking.always property. 
+     [hr]
+     Obtain an executor with the blocking.never property. 
+     [hr]
+     Obtain an executor with the relationship.fork property. 
+     [hr]
+     Obtain an executor with the relationship.continuation property. 
+     [hr]
+     Obtain an executor with the outstanding_work.tracked property. 
+     [hr]
+     Obtain an executor with the outstanding_work.untracked property. 
+     [hr]
+     Obtain an executor with the specified allocator property. 
+     [hr]
+     Obtain an executor with the default allocator property. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.running_in_this_thread [*running_in_this_thread]]]
+    [Determine whether the thread pool is running in the current thread. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type._basic_executor_type [*~basic_executor_type]]]
+    [Destructor. ]
+  ]
+  
+]
+
+[heading Friends]
+[table
+  [[Name][Description]]
+
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.operator_not__eq_ [*operator!=]]]
+    [Compare two executors for inequality. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.operator_eq__eq_ [*operator==]]]
+    [Compare two executors for equality. ]
+  ]
+  
+]
+
+
+[heading Requirements]
+
+['Header: ][^asio/thread_pool.hpp]
+
+['Convenience header: ][^asio.hpp]
+
+
+[endsect]
+
+
+
 [section:fork_event thread_pool::fork_event]
 
 
@@ -116419,6 +125788,22 @@ This overload is preserved for backwards compatibility with services that inheri
 [endsect]
 
 
+[section:wait thread_pool::wait]
+
+[indexterm2 asio.indexterm.thread_pool.wait..wait..thread_pool] 
+Waits for threads to complete. 
+
+
+  void wait();
+
+
+This function blocks until the threads in the pool have completed. If `stop()` is not called prior to `wait()`, the `wait()` call will wait until the pool has no more outstanding work. 
+
+
+[endsect]
+
+
+
 [section:_thread_pool thread_pool::~thread_pool]
 
 [indexterm2 asio.indexterm.thread_pool._thread_pool..~thread_pool..thread_pool] 
@@ -116437,13 +125822,16 @@ Automatically stops and joins the pool, if not explicitly done beforehand.
 
 [endsect]
 
-[section:thread_pool__executor_type thread_pool::executor_type]
+[section:thread_pool__basic_executor_type thread_pool::basic_executor_type]
 
 
-Executor used to submit functions to a thread pool. 
+Executor implementation type used to submit functions to a thread pool. 
 
 
-  class executor_type
+  template<
+      typename Allocator,
+      unsigned int Bits>
+  class basic_executor_type
 
 
 [heading Member Functions]
@@ -116451,40 +125839,107 @@ Executor used to submit functions to a thread pool.
   [[Name][Description]]
 
   [
-    [[link asio.reference.thread_pool__executor_type.context [*context]]]
+    [[link asio.reference.thread_pool__basic_executor_type.basic_executor_type [*basic_executor_type]]]
+    [Copy construtor. 
+     [hr]
+     Move construtor. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.context [*context]]]
     [Obtain the underlying execution context. ]
   ]
   
   [
-    [[link asio.reference.thread_pool__executor_type.defer [*defer]]]
+    [[link asio.reference.thread_pool__basic_executor_type.defer [*defer]]]
     [Request the thread pool to invoke the given function object. ]
   ]
   
   [
-    [[link asio.reference.thread_pool__executor_type.dispatch [*dispatch]]]
+    [[link asio.reference.thread_pool__basic_executor_type.dispatch [*dispatch]]]
     [Request the thread pool to invoke the given function object. ]
   ]
   
   [
-    [[link asio.reference.thread_pool__executor_type.on_work_finished [*on_work_finished]]]
+    [[link asio.reference.thread_pool__basic_executor_type.execute [*execute]]]
+    [Execution function. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.on_work_finished [*on_work_finished]]]
     [Inform the thread pool that some work is no longer outstanding. ]
   ]
   
   [
-    [[link asio.reference.thread_pool__executor_type.on_work_started [*on_work_started]]]
+    [[link asio.reference.thread_pool__basic_executor_type.on_work_started [*on_work_started]]]
     [Inform the thread pool that it has some outstanding work to do. ]
   ]
   
   [
-    [[link asio.reference.thread_pool__executor_type.post [*post]]]
+    [[link asio.reference.thread_pool__basic_executor_type.operator_eq_ [*operator=]]]
+    [Assignment operator. 
+     [hr]
+     Move assignment operator. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.post [*post]]]
     [Request the thread pool to invoke the given function object. ]
   ]
   
   [
-    [[link asio.reference.thread_pool__executor_type.running_in_this_thread [*running_in_this_thread]]]
+    [[link asio.reference.thread_pool__basic_executor_type.query [*query]]]
+    [Query the current value of the context property. 
+     [hr]
+     Query the current value of the blocking property. 
+     [hr]
+     Query the current value of the relationship property. 
+     [hr]
+     Query the current value of the allocator property. 
+     [hr]
+     Query the occupancy (recommended number of work items) for the pool. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.query__static [*query]]]
+    [Query the current value of the bulk_guarantee property. 
+     [hr]
+     Query the current value of the mapping property. 
+     [hr]
+     Query the current value of the outstanding_work property. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.require [*require]]]
+    [Obtain an executor with the blocking.possibly property. 
+     [hr]
+     Obtain an executor with the blocking.always property. 
+     [hr]
+     Obtain an executor with the blocking.never property. 
+     [hr]
+     Obtain an executor with the relationship.fork property. 
+     [hr]
+     Obtain an executor with the relationship.continuation property. 
+     [hr]
+     Obtain an executor with the outstanding_work.tracked property. 
+     [hr]
+     Obtain an executor with the outstanding_work.untracked property. 
+     [hr]
+     Obtain an executor with the specified allocator property. 
+     [hr]
+     Obtain an executor with the default allocator property. ]
+  ]
+  
+  [
+    [[link asio.reference.thread_pool__basic_executor_type.running_in_this_thread [*running_in_this_thread]]]
     [Determine whether the thread pool is running in the current thread. ]
   ]
   
+  [
+    [[link asio.reference.thread_pool__basic_executor_type._basic_executor_type [*~basic_executor_type]]]
+    [Destructor. ]
+  ]
+  
 ]
 
 [heading Friends]
@@ -116492,12 +125947,12 @@ Executor used to submit functions to a thread pool.
   [[Name][Description]]
 
   [
-    [[link asio.reference.thread_pool__executor_type.operator_not__eq_ [*operator!=]]]
+    [[link asio.reference.thread_pool__basic_executor_type.operator_not__eq_ [*operator!=]]]
     [Compare two executors for inequality. ]
   ]
   
   [
-    [[link asio.reference.thread_pool__executor_type.operator_eq__eq_ [*operator==]]]
+    [[link asio.reference.thread_pool__basic_executor_type.operator_eq__eq_ [*operator==]]]
     [Compare two executors for equality. ]
   ]
   
@@ -116509,10 +125964,60 @@ Executor used to submit functions to a thread pool.
 
 ['Convenience header: ][^asio.hpp]
 
+[section:basic_executor_type thread_pool::basic_executor_type::basic_executor_type]
 
-[section:context thread_pool::executor_type::context]
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.basic_executor_type..basic_executor_type..thread_pool::basic_executor_type] 
+Copy construtor. 
 
-[indexterm2 asio.indexterm.thread_pool__executor_type.context..context..thread_pool::executor_type] 
+
+  ``[link asio.reference.thread_pool__basic_executor_type.basic_executor_type.overload1 basic_executor_type]``(
+      const basic_executor_type & other);
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.basic_executor_type.overload1 more...]]``
+
+
+Move construtor. 
+
+
+  ``[link asio.reference.thread_pool__basic_executor_type.basic_executor_type.overload2 basic_executor_type]``(
+      basic_executor_type && other);
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.basic_executor_type.overload2 more...]]``
+
+
+[section:overload1 thread_pool::basic_executor_type::basic_executor_type (1 of 2 overloads)]
+
+
+Copy construtor. 
+
+
+  basic_executor_type(
+      const basic_executor_type & other);
+
+
+
+[endsect]
+
+
+
+[section:overload2 thread_pool::basic_executor_type::basic_executor_type (2 of 2 overloads)]
+
+
+Move construtor. 
+
+
+  basic_executor_type(
+      basic_executor_type && other);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:context thread_pool::basic_executor_type::context]
+
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.context..context..thread_pool::basic_executor_type] 
 Obtain the underlying execution context. 
 
 
@@ -116524,18 +126029,18 @@ Obtain the underlying execution context.
 
 
 
-[section:defer thread_pool::executor_type::defer]
+[section:defer thread_pool::basic_executor_type::defer]
 
-[indexterm2 asio.indexterm.thread_pool__executor_type.defer..defer..thread_pool::executor_type] 
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.defer..defer..thread_pool::basic_executor_type] 
 Request the thread pool to invoke the given function object. 
 
 
   template<
       typename Function,
-      typename Allocator>
+      typename OtherAllocator>
   void defer(
       Function && f,
-      const Allocator & a) const;
+      const OtherAllocator & a) const;
 
 
 This function is used to ask the thread pool to execute the given function object. The function object will never be executed inside `defer()`. Instead, it will be scheduled to run on the thread pool.
@@ -116565,18 +126070,18 @@ If the current thread belongs to the thread pool, `defer()` will delay schedulin
 
 
 
-[section:dispatch thread_pool::executor_type::dispatch]
+[section:dispatch thread_pool::basic_executor_type::dispatch]
 
-[indexterm2 asio.indexterm.thread_pool__executor_type.dispatch..dispatch..thread_pool::executor_type] 
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.dispatch..dispatch..thread_pool::basic_executor_type] 
 Request the thread pool to invoke the given function object. 
 
 
   template<
       typename Function,
-      typename Allocator>
+      typename OtherAllocator>
   void dispatch(
       Function && f,
-      const Allocator & a) const;
+      const OtherAllocator & a) const;
 
 
 This function is used to ask the thread pool to execute the given function object. If the current thread belongs to the pool, `dispatch()` executes the function before returning. Otherwise, the function will be scheduled to run on the thread pool.
@@ -116604,9 +126109,26 @@ This function is used to ask the thread pool to execute the given function objec
 
 
 
-[section:on_work_finished thread_pool::executor_type::on_work_finished]
+[section:execute thread_pool::basic_executor_type::execute]
 
-[indexterm2 asio.indexterm.thread_pool__executor_type.on_work_finished..on_work_finished..thread_pool::executor_type] 
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.execute..execute..thread_pool::basic_executor_type] 
+Execution function. 
+
+
+  template<
+      typename Function>
+  void execute(
+      Function && f) const;
+
+
+
+[endsect]
+
+
+
+[section:on_work_finished thread_pool::basic_executor_type::on_work_finished]
+
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.on_work_finished..on_work_finished..thread_pool::basic_executor_type] 
 Inform the thread pool that some work is no longer outstanding. 
 
 
@@ -116620,9 +126142,9 @@ This function is used to inform the thread pool that some work has finished. Onc
 
 
 
-[section:on_work_started thread_pool::executor_type::on_work_started]
+[section:on_work_started thread_pool::basic_executor_type::on_work_started]
 
-[indexterm2 asio.indexterm.thread_pool__executor_type.on_work_started..on_work_started..thread_pool::executor_type] 
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.on_work_started..on_work_started..thread_pool::basic_executor_type] 
 Inform the thread pool that it has some outstanding work to do. 
 
 
@@ -116636,15 +126158,15 @@ This function is used to inform the thread pool that some work has begun. This e
 
 
 
-[section:operator_not__eq_ thread_pool::executor_type::operator!=]
+[section:operator_not__eq_ thread_pool::basic_executor_type::operator!=]
 
-[indexterm2 asio.indexterm.thread_pool__executor_type.operator_not__eq_..operator!=..thread_pool::executor_type] 
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.operator_not__eq_..operator!=..thread_pool::basic_executor_type] 
 Compare two executors for inequality. 
 
 
   friend bool operator!=(
-      const executor_type & a,
-      const executor_type & b);
+      const basic_executor_type & a,
+      const basic_executor_type & b);
 
 
 Two executors are equal if they refer to the same underlying thread pool. 
@@ -116659,16 +126181,66 @@ Two executors are equal if they refer to the same underlying thread pool.
 [endsect]
 
 
+[section:operator_eq_ thread_pool::basic_executor_type::operator=]
 
-[section:operator_eq__eq_ thread_pool::executor_type::operator==]
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.operator_eq_..operator=..thread_pool::basic_executor_type] 
+Assignment operator. 
 
-[indexterm2 asio.indexterm.thread_pool__executor_type.operator_eq__eq_..operator==..thread_pool::executor_type] 
+
+  basic_executor_type & ``[link asio.reference.thread_pool__basic_executor_type.operator_eq_.overload1 operator=]``(
+      const basic_executor_type & other);
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.operator_eq_.overload1 more...]]``
+
+
+Move assignment operator. 
+
+
+  basic_executor_type & ``[link asio.reference.thread_pool__basic_executor_type.operator_eq_.overload2 operator=]``(
+      basic_executor_type && other);
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.operator_eq_.overload2 more...]]``
+
+
+[section:overload1 thread_pool::basic_executor_type::operator= (1 of 2 overloads)]
+
+
+Assignment operator. 
+
+
+  basic_executor_type & operator=(
+      const basic_executor_type & other);
+
+
+
+[endsect]
+
+
+
+[section:overload2 thread_pool::basic_executor_type::operator= (2 of 2 overloads)]
+
+
+Move assignment operator. 
+
+
+  basic_executor_type & operator=(
+      basic_executor_type && other);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:operator_eq__eq_ thread_pool::basic_executor_type::operator==]
+
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.operator_eq__eq_..operator==..thread_pool::basic_executor_type] 
 Compare two executors for equality. 
 
 
   friend bool operator==(
-      const executor_type & a,
-      const executor_type & b);
+      const basic_executor_type & a,
+      const basic_executor_type & b);
 
 
 Two executors are equal if they refer to the same underlying thread pool. 
@@ -116684,18 +126256,18 @@ Two executors are equal if they refer to the same underlying thread pool.
 
 
 
-[section:post thread_pool::executor_type::post]
+[section:post thread_pool::basic_executor_type::post]
 
-[indexterm2 asio.indexterm.thread_pool__executor_type.post..post..thread_pool::executor_type] 
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.post..post..thread_pool::basic_executor_type] 
 Request the thread pool to invoke the given function object. 
 
 
   template<
       typename Function,
-      typename Allocator>
+      typename OtherAllocator>
   void post(
       Function && f,
-      const Allocator & a) const;
+      const OtherAllocator & a) const;
 
 
 This function is used to ask the thread pool to execute the given function object. The function object will never be executed inside `post()`. Instead, it will be scheduled to run on the thread pool.
@@ -116722,10 +126294,440 @@ This function is used to ask the thread pool to execute the given function objec
 [endsect]
 
 
+[section:query thread_pool::basic_executor_type::query]
 
-[section:running_in_this_thread thread_pool::executor_type::running_in_this_thread]
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.query..query..thread_pool::basic_executor_type] 
+Query the current value of the `context` property. 
 
-[indexterm2 asio.indexterm.thread_pool__executor_type.running_in_this_thread..running_in_this_thread..thread_pool::executor_type] 
+
+  thread_pool & ``[link asio.reference.thread_pool__basic_executor_type.query.overload1 query]``(
+      execution::context_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query.overload1 more...]]``
+
+
+Query the current value of the `blocking` property. 
+
+
+  constexpr execution::blocking_t ``[link asio.reference.thread_pool__basic_executor_type.query.overload2 query]``(
+      execution::blocking_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query.overload2 more...]]``
+
+
+Query the current value of the `relationship` property. 
+
+
+  constexpr execution::relationship_t ``[link asio.reference.thread_pool__basic_executor_type.query.overload3 query]``(
+      execution::relationship_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query.overload3 more...]]``
+
+
+Query the current value of the `allocator` property. 
+
+
+  template<
+      typename OtherAllocator>
+  constexpr Allocator ``[link asio.reference.thread_pool__basic_executor_type.query.overload4 query]``(
+      execution::allocator_t< OtherAllocator > ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query.overload4 more...]]``
+
+  constexpr Allocator ``[link asio.reference.thread_pool__basic_executor_type.query.overload5 query]``(
+      execution::allocator_t< void > ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query.overload5 more...]]``
+
+
+Query the occupancy (recommended number of work items) for the pool. 
+
+
+  std::size_t ``[link asio.reference.thread_pool__basic_executor_type.query.overload6 query]``(
+      execution::occupancy_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query.overload6 more...]]``
+
+
+[section:overload1 thread_pool::basic_executor_type::query (1 of 6 overloads)]
+
+
+Query the current value of the `context` property. 
+
+
+  thread_pool & query(
+      execution::context_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 thread_pool::basic_executor_type::query (2 of 6 overloads)]
+
+
+Query the current value of the `blocking` property. 
+
+
+  constexpr execution::blocking_t query(
+      execution::blocking_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload3 thread_pool::basic_executor_type::query (3 of 6 overloads)]
+
+
+Query the current value of the `relationship` property. 
+
+
+  constexpr execution::relationship_t query(
+      execution::relationship_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload4 thread_pool::basic_executor_type::query (4 of 6 overloads)]
+
+
+Query the current value of the `allocator` property. 
+
+
+  template<
+      typename OtherAllocator>
+  constexpr Allocator query(
+      execution::allocator_t< OtherAllocator > ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload5 thread_pool::basic_executor_type::query (5 of 6 overloads)]
+
+
+Query the current value of the `allocator` property. 
+
+
+  constexpr Allocator query(
+      execution::allocator_t< void > ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload6 thread_pool::basic_executor_type::query (6 of 6 overloads)]
+
+
+Query the occupancy (recommended number of work items) for the pool. 
+
+
+  std::size_t query(
+      execution::occupancy_t ) const;
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:query__static thread_pool::basic_executor_type::query]
+
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.query__static..query..thread_pool::basic_executor_type] 
+Query the current value of the `bulk_guarantee` property. 
+
+
+  static constexpr execution::bulk_guarantee_t ``[link asio.reference.thread_pool__basic_executor_type.query__static.overload1 query]``(
+      execution::bulk_guarantee_t );
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query__static.overload1 more...]]``
+
+
+Query the current value of the `mapping` property. 
+
+
+  static constexpr execution::mapping_t ``[link asio.reference.thread_pool__basic_executor_type.query__static.overload2 query]``(
+      execution::mapping_t );
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query__static.overload2 more...]]``
+
+
+Query the current value of the `outstanding_work` property. 
+
+
+  static constexpr execution::outstanding_work_t ``[link asio.reference.thread_pool__basic_executor_type.query__static.overload3 query]``(
+      execution::outstanding_work_t );
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query__static.overload3 more...]]``
+
+
+[section:overload1 thread_pool::basic_executor_type::query (1 of 3 overloads)]
+
+
+Query the current value of the `bulk_guarantee` property. 
+
+
+  static constexpr execution::bulk_guarantee_t query(
+      execution::bulk_guarantee_t );
+
+
+
+[endsect]
+
+
+
+[section:overload2 thread_pool::basic_executor_type::query (2 of 3 overloads)]
+
+
+Query the current value of the `mapping` property. 
+
+
+  static constexpr execution::mapping_t query(
+      execution::mapping_t );
+
+
+
+[endsect]
+
+
+
+[section:overload3 thread_pool::basic_executor_type::query (3 of 3 overloads)]
+
+
+Query the current value of the `outstanding_work` property. 
+
+
+  static constexpr execution::outstanding_work_t query(
+      execution::outstanding_work_t );
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:require thread_pool::basic_executor_type::require]
+
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.require..require..thread_pool::basic_executor_type] 
+Obtain an executor with the `blocking.possibly` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.thread_pool__basic_executor_type.require.overload1 require]``(
+      execution::blocking_t::possibly_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload1 more...]]``
+
+
+Obtain an executor with the `blocking.always` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.thread_pool__basic_executor_type.require.overload2 require]``(
+      execution::blocking_t::always_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload2 more...]]``
+
+
+Obtain an executor with the `blocking.never` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.thread_pool__basic_executor_type.require.overload3 require]``(
+      execution::blocking_t::never_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload3 more...]]``
+
+
+Obtain an executor with the `relationship.fork` property. 
+
+
+  constexpr basic_executor_type ``[link asio.reference.thread_pool__basic_executor_type.require.overload4 require]``(
+      execution::relationship_t::fork_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload4 more...]]``
+
+
+Obtain an executor with the `relationship.continuation` property. 
+
+
+  constexpr basic_executor_type ``[link asio.reference.thread_pool__basic_executor_type.require.overload5 require]``(
+      execution::relationship_t::continuation_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload5 more...]]``
+
+
+Obtain an executor with the `outstanding_work.tracked` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.thread_pool__basic_executor_type.require.overload6 require]``(
+      execution::outstanding_work_t::tracked_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload6 more...]]``
+
+
+Obtain an executor with the `outstanding_work.untracked` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.thread_pool__basic_executor_type.require.overload7 require]``(
+      execution::outstanding_work_t::untracked_t ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload7 more...]]``
+
+
+Obtain an executor with the specified `allocator` property. 
+
+
+  template<
+      typename OtherAllocator>
+  constexpr basic_executor_type< OtherAllocator, Bits > ``[link asio.reference.thread_pool__basic_executor_type.require.overload8 require]``(
+      execution::allocator_t< OtherAllocator > a) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload8 more...]]``
+
+
+Obtain an executor with the default `allocator` property. 
+
+
+  constexpr basic_executor_type< std::allocator< void >, Bits > ``[link asio.reference.thread_pool__basic_executor_type.require.overload9 require]``(
+      execution::allocator_t< void > ) const;
+  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload9 more...]]``
+
+
+[section:overload1 thread_pool::basic_executor_type::require (1 of 9 overloads)]
+
+
+Obtain an executor with the `blocking.possibly` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > require(
+      execution::blocking_t::possibly_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 thread_pool::basic_executor_type::require (2 of 9 overloads)]
+
+
+Obtain an executor with the `blocking.always` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > require(
+      execution::blocking_t::always_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload3 thread_pool::basic_executor_type::require (3 of 9 overloads)]
+
+
+Obtain an executor with the `blocking.never` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > require(
+      execution::blocking_t::never_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload4 thread_pool::basic_executor_type::require (4 of 9 overloads)]
+
+
+Obtain an executor with the `relationship.fork` property. 
+
+
+  constexpr basic_executor_type require(
+      execution::relationship_t::fork_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload5 thread_pool::basic_executor_type::require (5 of 9 overloads)]
+
+
+Obtain an executor with the `relationship.continuation` property. 
+
+
+  constexpr basic_executor_type require(
+      execution::relationship_t::continuation_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload6 thread_pool::basic_executor_type::require (6 of 9 overloads)]
+
+
+Obtain an executor with the `outstanding_work.tracked` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > require(
+      execution::outstanding_work_t::tracked_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload7 thread_pool::basic_executor_type::require (7 of 9 overloads)]
+
+
+Obtain an executor with the `outstanding_work.untracked` property. 
+
+
+  constexpr basic_executor_type< Allocator, unspecified > require(
+      execution::outstanding_work_t::untracked_t ) const;
+
+
+
+[endsect]
+
+
+
+[section:overload8 thread_pool::basic_executor_type::require (8 of 9 overloads)]
+
+
+Obtain an executor with the specified `allocator` property. 
+
+
+  template<
+      typename OtherAllocator>
+  constexpr basic_executor_type< OtherAllocator, Bits > require(
+      execution::allocator_t< OtherAllocator > a) const;
+
+
+
+[endsect]
+
+
+
+[section:overload9 thread_pool::basic_executor_type::require (9 of 9 overloads)]
+
+
+Obtain an executor with the default `allocator` property. 
+
+
+  constexpr basic_executor_type< std::allocator< void >, Bits > require(
+      execution::allocator_t< void > ) const;
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:running_in_this_thread thread_pool::basic_executor_type::running_in_this_thread]
+
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type.running_in_this_thread..running_in_this_thread..thread_pool::basic_executor_type] 
 Determine whether the thread pool is running in the current thread. 
 
 
@@ -116735,11 +126737,25 @@ Determine whether the thread pool is running in the current thread.
 
 [heading Return Value]
       
-`true` if the current thread belongs to the pool. Otherwise returns `false`. 
+`true` if the current thread is running the thread pool. Otherwise returns `false`. 
 
 
 
 
+[endsect]
+
+
+
+[section:_basic_executor_type thread_pool::basic_executor_type::~basic_executor_type]
+
+[indexterm2 asio.indexterm.thread_pool__basic_executor_type._basic_executor_type..~basic_executor_type..thread_pool::basic_executor_type] 
+Destructor. 
+
+
+  ~basic_executor_type();
+
+
+
 [endsect]
 
 
@@ -117104,7 +127120,7 @@ A completion token that represents the currently executing coroutine.
 
 
   template<
-      typename ``[link asio.reference.Executor1 Executor]`` = executor>
+      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
   struct use_awaitable_t
 
 
@@ -117132,7 +127148,9 @@ A completion token that represents the currently executing coroutine.
   
   [
     [[link asio.reference.use_awaitable_t.use_awaitable_t [*use_awaitable_t]]]
-    [Default constructor. ]
+    [Default constructor. 
+     [hr]
+     Constructor used to specify file name, line, and function name. ]
   ]
   
 ]
@@ -117175,10 +127193,29 @@ Function helper to adapt an I/O object to use `use_awaitable_t` as its default c
 [endsect]
 
 
-
 [section:use_awaitable_t use_awaitable_t::use_awaitable_t]
 
 [indexterm2 asio.indexterm.use_awaitable_t.use_awaitable_t..use_awaitable_t..use_awaitable_t] 
+Default constructor. 
+
+
+  constexpr ``[link asio.reference.use_awaitable_t.use_awaitable_t.overload1 use_awaitable_t]``();
+  ``  [''''&raquo;''' [link asio.reference.use_awaitable_t.use_awaitable_t.overload1 more...]]``
+
+
+Constructor used to specify file name, line, and function name. 
+
+
+  constexpr ``[link asio.reference.use_awaitable_t.use_awaitable_t.overload2 use_awaitable_t]``(
+      const char * file_name,
+      int line,
+      const char * function_name);
+  ``  [''''&raquo;''' [link asio.reference.use_awaitable_t.use_awaitable_t.overload2 more...]]``
+
+
+[section:overload1 use_awaitable_t::use_awaitable_t (1 of 2 overloads)]
+
+
 Default constructor. 
 
 
@@ -117190,6 +127227,25 @@ Default constructor.
 
 
 
+[section:overload2 use_awaitable_t::use_awaitable_t (2 of 2 overloads)]
+
+
+Constructor used to specify file name, line, and function name. 
+
+
+  constexpr use_awaitable_t(
+      const char * file_name,
+      int line,
+      const char * function_name);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
 [endsect]
 
 [section:use_awaitable_t__executor_with_default use_awaitable_t::executor_with_default]
@@ -117222,7 +127278,9 @@ Adapts an executor to add the `use_awaitable_t` completion token as the default.
 
   [
     [[link asio.reference.use_awaitable_t__executor_with_default.executor_with_default [*executor_with_default]]]
-    [Construct the adapted executor from the inner executor type. ]
+    [Construct the adapted executor from the inner executor type. 
+     [hr]
+     Convert the specified executor to the inner executor type, then use that to construct the adapted executor. ]
   ]
   
 ]
@@ -117267,7 +127325,9 @@ Specify `use_awaitable_t` as the default completion token type.
   
   [
     [[link asio.reference.use_awaitable_t.use_awaitable_t [*use_awaitable_t]]]
-    [Default constructor. ]
+    [Default constructor. 
+     [hr]
+     Constructor used to specify file name, line, and function name. ]
   ]
   
 ]
@@ -117298,10 +127358,31 @@ When used with co\_await, the initiating function (`async_read_some` in the abov
 [endsect]
 
 
-
 [section:executor_with_default use_awaitable_t::executor_with_default::executor_with_default]
 
 [indexterm2 asio.indexterm.use_awaitable_t__executor_with_default.executor_with_default..executor_with_default..use_awaitable_t::executor_with_default] 
+Construct the adapted executor from the inner executor type. 
+
+
+  ``[link asio.reference.use_awaitable_t__executor_with_default.executor_with_default.overload1 executor_with_default]``(
+      const InnerExecutor & ex);
+  ``  [''''&raquo;''' [link asio.reference.use_awaitable_t__executor_with_default.executor_with_default.overload1 more...]]``
+
+
+Convert the specified executor to the inner executor type, then use that to construct the adapted executor. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 OtherExecutor]``>
+  ``[link asio.reference.use_awaitable_t__executor_with_default.executor_with_default.overload2 executor_with_default]``(
+      const OtherExecutor & ex,
+      typename enable_if< is_convertible< OtherExecutor, InnerExecutor >::value >::type *  = 0);
+  ``  [''''&raquo;''' [link asio.reference.use_awaitable_t__executor_with_default.executor_with_default.overload2 more...]]``
+
+
+[section:overload1 use_awaitable_t::executor_with_default::executor_with_default (1 of 2 overloads)]
+
+
 Construct the adapted executor from the inner executor type. 
 
 
@@ -117314,6 +127395,26 @@ Construct the adapted executor from the inner executor type.
 
 
 
+[section:overload2 use_awaitable_t::executor_with_default::executor_with_default (2 of 2 overloads)]
+
+
+Convert the specified executor to the inner executor type, then use that to construct the adapted executor. 
+
+
+  template<
+      typename ``[link asio.reference.Executor1 OtherExecutor]``>
+  executor_with_default(
+      const OtherExecutor & ex,
+      typename enable_if< is_convertible< OtherExecutor, InnerExecutor >::value >::type *  = 0);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
 [endsect]
 
 
@@ -117580,10 +127681,11 @@ The [link asio.reference.uses_executor `uses_executor`] trait detects whether a
   template<
       typename T,
       typename ``[link asio.reference.Executor1 Executor]``>
-  struct uses_executor
+  struct uses_executor :
+    public false_type
 
 
-Meets the BinaryTypeTrait requirements. The Asio library provides a definition that is derived from false\_type. A program may specialize this template to derive from true\_type for a user-defined type T that can be constructed with an executor, where the first argument of a constructor has type [link asio.reference.executor_arg_t `executor_arg_t`] and the second argument is convertible from type Executor. 
+Meets the BinaryTypeTrait requirements. The Asio library provides a definition that is derived from `false_type`. A program may specialize this template to derive from true\_type for a user-defined type T that can be constructed with an executor, where the first argument of a constructor has type [link asio.reference.executor_arg_t `executor_arg_t`] and the second argument is convertible from type Executor. 
 
 [heading Requirements]
 
@@ -117692,7 +127794,7 @@ Provides object-oriented handle functionality.
 
 
   template<
-      typename ``[link asio.reference.Executor1 Executor]`` = executor>
+      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
   class basic_object_handle
 
 
@@ -118834,7 +128936,7 @@ Provides Windows handle functionality for objects that support overlapped I/O.
 
 
   template<
-      typename ``[link asio.reference.Executor1 Executor]`` = executor>
+      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
   class basic_overlapped_handle
 
 
@@ -119931,7 +130033,7 @@ Provides random-access handle functionality.
 
 
   template<
-      typename ``[link asio.reference.Executor1 Executor]`` = executor>
+      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
   class basic_random_access_handle :
     public windows::basic_overlapped_handle< Executor >
 
@@ -121458,7 +131560,7 @@ Provides stream-oriented handle functionality.
 
 
   template<
-      typename ``[link asio.reference.Executor1 Executor]`` = executor>
+      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
   class basic_stream_handle :
     public windows::basic_overlapped_handle< Executor >
 
@@ -123389,7 +133491,7 @@ Construct an [link asio.reference.windows__overlapped_ptr `windows::overlapped_p
   explicit ``[link asio.reference.windows__overlapped_ptr.overlapped_ptr.overload3 overlapped_ptr]``(
       const Executor & ex,
       Handler && handler,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< execution::is_executor< Executor >::value||is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.windows__overlapped_ptr.overlapped_ptr.overload3 more...]]``
 
 
@@ -123439,7 +133541,7 @@ Construct an [link asio.reference.windows__overlapped_ptr `windows::overlapped_p
   overlapped_ptr(
       const Executor & ex,
       Handler && handler,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< execution::is_executor< Executor >::value||is_executor< Executor >::value >::type *  = 0);
 
 
 
@@ -123490,7 +133592,7 @@ Reset to contain the specified handler, freeing any current OVERLAPPED object.
   void ``[link asio.reference.windows__overlapped_ptr.reset.overload3 reset]``(
       const Executor & ex,
       Handler && handler,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< execution::is_executor< Executor >::value||is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link asio.reference.windows__overlapped_ptr.reset.overload3 more...]]``
 
 
@@ -123540,7 +133642,7 @@ Reset to contain the specified handler, freeing any current OVERLAPPED object.
   void reset(
       const Executor & ex,
       Handler && handler,
-      typename enable_if< is_executor< Executor >::value >::type *  = 0);
+      typename enable_if< execution::is_executor< Executor >::value||is_executor< Executor >::value >::type *  = 0);
 
 
 
@@ -125970,4 +136072,4 @@ The initiating function (async\_read\_some in the above example) suspends the cu
 [endsect]
 
 
-[endsect]
\ No newline at end of file
+[endsect]
diff --git a/asio/src/doc/tutorial.qbk b/asio/src/doc/tutorial.qbk
index 622fb5e3..23483650 100644
--- a/asio/src/doc/tutorial.qbk
+++ b/asio/src/doc/tutorial.qbk
@@ -1535,6 +1535,8 @@ We use an [link asio.reference.ip__udp.resolver ip::udp::resolver] object to fin
 
 The [link asio.reference.ip__basic_resolver.resolve ip::udp::resolver::resolve()] function is guaranteed to return at least one endpoint in the list if it does not fail. This means it is safe to dereference the return value directly.
 
+Since UDP is datagram-oriented, we will not be using a stream socket. Create an [link asio.reference.ip__udp.socket ip::udp::socket] and initiate contact with the remote endpoint.
+
 
 
   ``''''''``    udp::socket socket(io_context);
@@ -1543,26 +1545,32 @@ The [link asio.reference.ip__basic_resolver.resolve ip::udp::resolver::resolve()
   ``''''''``    boost::array<char, 1> send_buf  = {{ 0 }};
   ``''''''``    socket.send_to(asio::buffer(send_buf), receiver_endpoint);
 
-  ``''''''``    boost::array<char, 128> recv_buf;
-  ``''''''``    udp::endpoint sender_endpoint;
-
-
-
-Since UDP is datagram-oriented, we will not be using a stream socket. Create an [link asio.reference.ip__udp.socket ip::udp::socket] and initiate contact with the remote endpoint.
-
-
-
 
 
 Now we need to be ready to accept whatever the server sends back to us. The endpoint on our side that receives the server's response will be initialised by [link asio.reference.basic_datagram_socket.receive_from ip::udp::socket::receive_from()].
 
 
 
+  ``''''''``    boost::array<char, 128> recv_buf;
+  ``''''''``    udp::endpoint sender_endpoint;
+  ``''''''``    size_t len = socket.receive_from(
+  ``''''''``        asio::buffer(recv_buf), sender_endpoint);
+
+  ``''''''``    std::cout.write(recv_buf.data(), len);
+  ``''''''``  }
+
 
 
 Finally, handle any exceptions that may have been thrown.
 
 
+  ``''''''``  catch (std::exception& e)
+  ``''''''``  {
+  ``''''''``    std::cerr << e.what() << std::endl;
+  ``''''''``  }
+
+  ``''''''``  return 0;
+  ``''''''``}
 
 See the [link asio.tutorial.tutdaytime4.src full source listing]
 
@@ -2384,4 +2392,4 @@ See the [@http://www.boost.org/libs/bind/bind.html Boost: bind.hpp documentation
 [endsect]
 
 
-[endsect]
\ No newline at end of file
+[endsect]