Added deferred support, because it's asio's default now.

doc/reference/detached.adoc

@@ -101,4 +101,4 @@ The thread detached has the following properties.
 - <<enable_awaitables>>
 - <<enable_await_allocator>>
 - <<enable_await_executor>>
-
+- <<enable_await_deferred>>

doc/reference/promise.adoc

@@ -83,4 +83,4 @@ The coroutine promise (`promise::promise_type`) has the following properties.
 - <<enable_awaitables>>
 - <<enable_await_allocator>>
 - <<enable_await_executor>>
-
+- <<enable_await_deferred>>

doc/reference/task.adoc

@@ -62,6 +62,7 @@ The task promise has the following properties.
 - <<enable_awaitables>>
 - <<enable_await_allocator>>
 - <<enable_await_executor>>
+- <<enable_await_deferred>>
 
 [#use_task]
 === use_task

doc/reference/this_coro.adoc

@@ -59,6 +59,22 @@ struct my_promise : cobalt::enable_await_executor<my_promise>
 
 NOTE: If available the executor gets used by <<use_op>>
 
+[#enable_await_deferred]
+=== Await deferred
+
+Your coroutine promises can inherit `enable_await_deferred` so that
+a single signature `asio::deferred` in a `co_await` expression.
+
+Since `asio::deferred` is now the default completion token,
+this allows below code without specifying any completion token or other specialization.
+
+[source,cpp]
+----
+asio::steady_timer t{co_await cobalt::this_coro::executor};
+co_await t.async_wait();
+----
+
+
 [#promise_memory_resource_base]
 === Memory resource base
 

doc/reference/thread.adoc

@@ -81,4 +81,5 @@ The thread promise has the following properties.
 - <<enable_awaitables>>
 - <<enable_await_allocator>>
 - <<enable_await_executor>>
+- <<enable_await_deferred>>
 

include/boost/cobalt/detail/detached.hpp

@@ -12,12 +12,10 @@
 #include <boost/cobalt/detail/forward_cancellation.hpp>
 #include <boost/cobalt/detail/wrapper.hpp>
 #include <boost/cobalt/detail/this_thread.hpp>
+#include <boost/cobalt/op.hpp>
 
 #include <boost/asio/cancellation_signal.hpp>
 
-
-
-
 #include <boost/core/exchange.hpp>
 
 #include <coroutine>
@@ -39,13 +37,15 @@ struct detached_promise
       promise_throw_if_cancelled_base,
       enable_awaitables<detached_promise>,
       enable_await_allocator<detached_promise>,
-      enable_await_executor<detached_promise>
+      enable_await_executor<detached_promise>,
+      enable_await_deferred
 {
   using promise_cancellation_base<asio::cancellation_slot, asio::enable_total_cancellation>::await_transform;
   using promise_throw_if_cancelled_base::await_transform;
   using enable_awaitables<detached_promise>::await_transform;
   using enable_await_allocator<detached_promise>::await_transform;
   using enable_await_executor<detached_promise>::await_transform;
+  using enable_await_deferred::await_transform;
 
   [[nodiscard]] detached get_return_object();
 

include/boost/cobalt/detail/generator.hpp

@@ -15,6 +15,7 @@
 #include <boost/cobalt/detail/this_thread.hpp>
 #include <boost/cobalt/unique_handle.hpp>
 #include <boost/cobalt/detail/wrapper.hpp>
+#include <boost/cobalt/op.hpp>
 #include <boost/cobalt/noop.hpp>
 
 #include <boost/asio/bind_allocator.hpp>
@@ -347,13 +348,15 @@ struct generator_promise
       promise_throw_if_cancelled_base,
       enable_awaitables<generator_promise<Yield, Push>>,
       enable_await_allocator<generator_promise<Yield, Push>>,
-      enable_await_executor< generator_promise<Yield, Push>>
+      enable_await_executor< generator_promise<Yield, Push>>,
+      enable_await_deferred
 {
   using promise_cancellation_base<asio::cancellation_slot, asio::enable_total_cancellation>::await_transform;
   using promise_throw_if_cancelled_base::await_transform;
   using enable_awaitables<generator_promise<Yield, Push>>::await_transform;
   using enable_await_allocator<generator_promise<Yield, Push>>::await_transform;
   using enable_await_executor<generator_promise<Yield, Push>>::await_transform;
+  using enable_await_deferred::await_transform;
 
   [[nodiscard]] generator<Yield, Push> get_return_object()
   {

include/boost/cobalt/detail/main.hpp

@@ -9,9 +9,9 @@
 #define BOOST_DETAIL_COBALT_MAIN_HPP
 
 #include <boost/cobalt/main.hpp>
+#include <boost/cobalt/op.hpp>
 #include <boost/cobalt/this_coro.hpp>
 
-
 #include <boost/config.hpp>
 
 
@@ -41,7 +41,8 @@ struct main_promise : signal_helper,
                       promise_throw_if_cancelled_base,
                       enable_awaitables<main_promise>,
                       enable_await_allocator<main_promise>,
-                      enable_await_executor<main_promise>
+                      enable_await_executor<main_promise>,
+                      enable_await_deferred
 {
     main_promise(int, char **) : promise_cancellation_base<asio::cancellation_slot, asio::enable_total_cancellation>(
             signal_helper::signal.slot(), asio::enable_total_cancellation())
@@ -138,8 +139,9 @@ struct main_promise : signal_helper,
     using enable_awaitables<main_promise>::await_transform;
     using enable_await_allocator<main_promise>::await_transform;
     using enable_await_executor<main_promise>::await_transform;
+  using enable_await_deferred::await_transform;
 
-  private:
+ private:
     int * result;
     std::optional<asio::executor_work_guard<executor_type>> exec;
     std::optional<executor_type> exec_;

include/boost/cobalt/detail/promise.hpp

@@ -13,17 +13,16 @@
 #include <boost/cobalt/detail/wrapper.hpp>
 #include <boost/cobalt/detail/this_thread.hpp>
 #include <boost/cobalt/noop.hpp>
+#include <boost/cobalt/op.hpp>
 #include <boost/cobalt/unique_handle.hpp>
 
 #include <boost/asio/cancellation_signal.hpp>
-
+#include <boost/asio/bind_allocator.hpp>
 
 #include <boost/core/exchange.hpp>
-
 #include <coroutine>
 #include <optional>
 #include <utility>
-#include <boost/asio/bind_allocator.hpp>
 
 namespace boost::cobalt
 {
@@ -315,13 +314,15 @@ struct cobalt_promise
       enable_awaitables<cobalt_promise<Return>>,
       enable_await_allocator<cobalt_promise<Return>>,
       enable_await_executor<cobalt_promise<Return>>,
+      enable_await_deferred,
       cobalt_promise_result<Return>
 {
   using promise_cancellation_base<asio::cancellation_slot, asio::enable_total_cancellation>::await_transform;
   using promise_throw_if_cancelled_base::await_transform;
   using enable_awaitables<cobalt_promise<Return>>::await_transform;
   using enable_await_allocator<cobalt_promise<Return>>::await_transform;
   using enable_await_executor<cobalt_promise<Return>>::await_transform;
+  using enable_await_deferred::await_transform;
 
   [[nodiscard]] promise<Return> get_return_object()
   {

include/boost/cobalt/detail/task.hpp

@@ -13,6 +13,7 @@
 #include <boost/cobalt/detail/wrapper.hpp>
 #include <boost/cobalt/detail/this_thread.hpp>
 #include <boost/cobalt/noop.hpp>
+#include <boost/cobalt/op.hpp>
 
 #include <boost/asio/bind_allocator.hpp>
 #include <boost/asio/cancellation_signal.hpp>
@@ -288,13 +289,15 @@ struct task_promise
       enable_awaitables<task_promise<Return>>,
       enable_await_allocator<task_promise<Return>>,
       enable_await_executor<task_promise<Return>>,
+      enable_await_deferred,
       task_promise_result<Return>
 {
   using promise_cancellation_base<asio::cancellation_slot, asio::enable_total_cancellation>::await_transform;
   using promise_throw_if_cancelled_base::await_transform;
   using enable_awaitables<task_promise<Return>>::await_transform;
   using enable_await_allocator<task_promise<Return>>::await_transform;
   using enable_await_executor<task_promise<Return>>::await_transform;
+  using enable_await_deferred::await_transform;
 
   [[nodiscard]] task<Return> get_return_object()
   {

include/boost/cobalt/detail/thread.hpp

@@ -12,6 +12,7 @@
 #include <boost/cobalt/detail/forward_cancellation.hpp>
 #include <boost/cobalt/detail/handler.hpp>
 #include <boost/cobalt/concepts.hpp>
+#include <boost/cobalt/op.hpp>
 #include <boost/cobalt/this_coro.hpp>
 
 #include <boost/asio/cancellation_signal.hpp>
@@ -55,7 +56,8 @@ struct thread_promise : signal_helper_2,
                         promise_throw_if_cancelled_base,
                         enable_awaitables<thread_promise>,
                         enable_await_allocator<thread_promise>,
-                        enable_await_executor<thread_promise>
+                        enable_await_executor<thread_promise>,
+                        enable_await_deferred
 {
   BOOST_COBALT_DECL thread_promise();
 
@@ -101,6 +103,7 @@ struct thread_promise : signal_helper_2,
   using enable_awaitables<thread_promise>::await_transform;
   using enable_await_allocator<thread_promise>::await_transform;
   using enable_await_executor<thread_promise>::await_transform;
+  using enable_await_deferred::await_transform;
 
   BOOST_COBALT_DECL
   boost::cobalt::thread get_return_object();

include/boost/cobalt/op.hpp

@@ -13,6 +13,9 @@
 #include <boost/cobalt/result.hpp>
 #include <boost/core/no_exceptions_support.hpp>
 
+#include <boost/asio/deferred.hpp>
+
+
 namespace boost::cobalt
 {
 
@@ -96,9 +99,6 @@ struct op
         std::rethrow_exception(init_ep);
       return interpret_as_result(*std::move(result));
     }
-
-
-
   };
 
   awaitable operator co_await() &&
@@ -164,6 +164,27 @@ struct use_op_t
 
 constexpr use_op_t use_op{};
 
+struct enable_await_deferred
+{
+  template<typename ... Args, typename Initiation, typename ... InitArgs>
+  auto await_transform(asio::deferred_async_operation<void(Args...), Initiation, InitArgs...> op_)
+  {
+    struct deferred_op : op<Args...>
+    {
+      asio::deferred_async_operation<void(Args...), Initiation, InitArgs...> op_;
+      deferred_op(asio::deferred_async_operation<void(Args...), Initiation, InitArgs...> op_)
+          : op_(std::move(op_)) {}
+
+      void initiate(cobalt::completion_handler<Args...> complete) override
+      {
+        std::move(op_)(std::move(complete));
+      }
+    };
+
+    return deferred_op{std::move(op_)};
+  }
+};
+
 }
 
 namespace boost::asio
@@ -207,5 +228,8 @@ struct async_result<boost::cobalt::use_op_t, void(Args...)>
         std::forward<InitArgs>(args)...);
   }
 };
+
+
+
 }
 #endif //BOOST_COBALT_OP_HPP

test/op.cpp

@@ -9,6 +9,7 @@
 #include <boost/cobalt/spawn.hpp>
 #include <boost/cobalt/promise.hpp>
 
+#include <boost/asio/as_tuple.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/asio/experimental/channel.hpp>
 #include <boost/asio/steady_timer.hpp>
@@ -200,7 +201,13 @@ CO_TEST_CASE(no_move_from)
   BOOST_CHECK(p);
 }
 
+CO_TEST_CASE(deferred)
+{
+  asio::steady_timer tim{co_await asio::this_coro::executor, std::chrono::milliseconds(10)};
 
+  co_await post_op(co_await asio::this_coro::executor);
+  std::tuple<system::error_code> r = co_await tim.async_wait(asio::as_tuple);
+}
 
 
 BOOST_AUTO_TEST_SUITE_END();