asioexec::completion_token:: & ::use_sender::as_default_on

When an Asio asynchronous operation is parameterized by an executor or
an I/O object it can adopt the default completion token of that executor
or of the executor associated with that I/O object, if any. Adopting a
default completion token means that, if the initiating function does not
receive an explicit completion token parameter, it will be implicitly
parameterized by a default constructed instance of that default
completion token type.

Given that Asio I/O objects feature a rebind_executor nested template it
follows from this that one can rebind an I/O object to be associated
with an executor which exposes a certain default completion token. See
for example boost::asio::use_awaitable_t and asio::awaitable_t (in
Boost.Asio and standalone Asio, respectively). Therefore upgraded
asioexec::completion_token and ::use_sender to support the pattern
embodied by the aforementioned types from Boost.Asio/standalone Asio.
By using the newly-added as_default_on members thereof an I/O object may
be rebound to an executor type which causes that I/O object's initiating
functions (and free initiating functions parameterized thereby) to yield
a sender when no completion token is explicitly provided thereto.

See the newly-added unit tests for examples.

Author: RobertLeahy

include/asioexec/as_default_on.hpp

@@ -0,0 +1,50 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ *                         Copyright (c) 2025 Robert Leahy. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ * Licensed under the Apache License, Version 2.0 with LLVM Exceptions (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <type_traits>
+#include <utility>
+#include <asioexec/asio_config.hpp>
+#include <asioexec/executor_with_default.hpp>
+
+namespace asioexec {
+
+  template <typename CompletionToken, typename IoObject>
+  using as_default_on_t =
+    typename std::remove_cvref_t<IoObject>::template rebind_executor<executor_with_default<
+      std::remove_cvref_t<decltype(std::declval<IoObject&>().get_executor())>,
+      CompletionToken>>::other;
+
+  namespace detail::as_default_on {
+
+    template <typename CompletionToken>
+    struct t {
+      template <typename IoObject>
+      constexpr asioexec::as_default_on_t<CompletionToken, IoObject>
+        operator()(IoObject&& io) const {
+        return asioexec::as_default_on_t<CompletionToken, IoObject>((IoObject&&) io);
+      }
+    };
+
+  } // namespace detail::as_default_on
+
+  template <typename CompletionToken>
+  inline constexpr detail::as_default_on::t<CompletionToken> as_default_on;
+
+} // namespace asioexec

include/asioexec/completion_token.hpp

@@ -26,6 +26,7 @@
 #include <tuple>
 #include <type_traits>
 #include <utility>
+#include <asioexec/as_default_on.hpp>
 #include <asioexec/asio_config.hpp>
 #include <stdexec/execution.hpp>
 
@@ -485,7 +486,11 @@ namespace asioexec {
 
   } // namespace detail::completion_token
 
-  struct completion_token_t { };
+  struct completion_token_t {
+    static constexpr auto as_default_on = asioexec::as_default_on<completion_token_t>;
+    template <typename IoObject>
+    using as_default_on_t = asioexec::as_default_on_t<completion_token_t, IoObject>;
+  };
 
   inline const completion_token_t completion_token{};
 

include/asioexec/executor_with_default.hpp

@@ -0,0 +1,33 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ *                         Copyright (c) 2025 Robert Leahy. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ * Licensed under the Apache License, Version 2.0 with LLVM Exceptions (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <asioexec/asio_config.hpp>
+
+namespace asioexec {
+
+  template <typename Executor, typename CompletionToken>
+  struct executor_with_default : Executor {
+    using default_completion_token_type = CompletionToken;
+    executor_with_default(const Executor& ex) noexcept
+      : Executor(ex) {
+    }
+  };
+
+} // namespace asioexec

include/asioexec/use_sender.hpp

@@ -23,6 +23,7 @@
 #include <system_error>
 #include <type_traits>
 #include <utility>
+#include <asioexec/as_default_on.hpp>
 #include <asioexec/asio_config.hpp>
 #include <asioexec/completion_token.hpp>
 #include <stdexec/execution.hpp>
@@ -196,7 +197,11 @@ namespace asioexec {
 
   } // namespace detail::use_sender
 
-  struct use_sender_t { };
+  struct use_sender_t {
+    static constexpr auto as_default_on = asioexec::as_default_on<use_sender_t>;
+    template <typename IoObject>
+    using as_default_on_t = asioexec::as_default_on_t<use_sender_t, IoObject>;
+  };
 
   inline const use_sender_t use_sender{};
 

test/asioexec/test_completion_token.cpp

@@ -968,4 +968,22 @@ namespace {
     CHECK(ex);
   }
 
+  TEST_CASE(
+    "I/O objects may be transformed to use senders as their default vocabulary with only minimal "
+    "transformations (i.e. no error adaptation)",
+    "[asioexec][completion_token]") {
+    bool invoked = false;
+    asio_impl::io_context ctx;
+    auto t = completion_token.as_default_on(asio_impl::system_timer(ctx));
+    static_assert(
+      std::is_same_v<decltype(t), completion_token_t::as_default_on_t<asio_impl::system_timer>>);
+    t.expires_after(std::chrono::milliseconds(5));
+    auto op = ::stdexec::connect(
+      t.async_wait() | ::stdexec::then([](auto ec) { CHECK(!ec); }),
+      expect_void_receiver_ex(invoked));
+    ::stdexec::start(op);
+    CHECK(ctx.run() != 0);
+    CHECK(ctx.stopped());
+  }
+
 } // namespace

test/asioexec/test_use_sender.cpp

@@ -22,6 +22,7 @@
 #include <exception>
 #include <functional>
 #include <system_error>
+#include <type_traits>
 #include <utility>
 #include <asioexec/asio_config.hpp>
 #include <catch2/catch.hpp>
@@ -234,4 +235,19 @@ namespace {
     CHECK_THROWS_AS(std::rethrow_exception(std::move(ex)), std::system_error);
   }
 
+  TEST_CASE(
+    "I/O objects may be transformed to use senders as their default vocabulary",
+    "[asioexec][use_sender]") {
+    bool invoked = false;
+    asio_impl::io_context ctx;
+    auto t = use_sender.as_default_on(asio_impl::system_timer(ctx));
+    static_assert(
+      std::is_same_v<decltype(t), use_sender_t::as_default_on_t<asio_impl::system_timer>>);
+    t.expires_after(std::chrono::milliseconds(5));
+    auto op = ::stdexec::connect(t.async_wait(), expect_void_receiver_ex(invoked));
+    ::stdexec::start(op);
+    CHECK(ctx.run() != 0);
+    CHECK(ctx.stopped());
+  }
+
 } // namespace