Support returning void from alien coroutines (#42)

m-fila · web-flow · commit 5e2791044163 · 2026-02-09T11:15:33.000+01:00
* add support for void return type in alien coroutines

* lift default initialization requirement for return type

* fix emplace requirement, more consistency using `result_type`
diff --git a/examples/alien.cpp b/examples/alien.cpp
@@ -81,6 +81,22 @@ tool::Task<tool::StatusCode> tool3_execute(std::string_view parent) {
     }
 }
 
+// tool4: co_awaits a AsyncTimer, but return void result
+tool::Task<void> tool4_execute(std::string_view parent) {
+    const auto self = format_name(parent, "tool4");
+    log(self) << "Calling async API in tool4" << std::endl;
+    auto status = co_await AsyncTimer{std::chrono::milliseconds(50),
+                                      StatusCode::SUCCESS, self};
+    log(self) << "Result from async API in tool4: " << status << std::endl;
+    if (status.status() != StatusCode::SUCCESS) {
+        log(self) << "Async operation in tool4 failed, throwing exception"
+                  << std::endl;
+        throw std::runtime_error("tool4_async operation failed");
+    }
+    log(self) << "Finishing tool4" << std::endl;
+    co_return;
+}
+
 // Task: co_awaits AsyncTimer then tool1_execute then tool2_execute then
 // tool3_execute
 algorithm::Task<algorithm::StatusCode> algorithm_execute(
@@ -105,6 +121,9 @@ algorithm::Task<algorithm::StatusCode> algorithm_execute(
         log(self) << "Caught exception  (expected) from tool3: " << e.what()
                   << std::endl;
     }
+    log(self) << "Launching tool4" << std::endl;
+    co_await tool4_execute(self);
+    log(self) << "tool4 done" << std::endl;
     log(self) << "Finishing algorithm" << std::endl;
     co_return algorithm::StatusCode::SUCCESS;
 }
diff --git a/include/CoroutineTests/alien/subtool.hpp b/include/CoroutineTests/alien/subtool.hpp
@@ -6,6 +6,7 @@
 #include <exception>
 #include <functional>
 #include <iostream>
+#include <optional>
 
 namespace CoroutineTests::alien::subtool {
 
@@ -51,17 +52,17 @@ concept HasScheduler = requires(T t) {
 }  // namespace concepts
 
 // Nestable coroutine, can be co_awaited by other coroutines.
-// Returns a single value of templated type via co_return, doesn't co_yield.
+// Returns a single value of templated type via co_return if it isn't void
+// Doesn't co_yield.
 template <typename ResultType>
 class [[nodiscard]] Task {
 
-    static_assert(
-        std::default_initializable<ResultType>,
-        "Task<ResultType> requires ResultType to be default-initializable");
-    static_assert(std::movable<ResultType>,
-                  "Task<ResultType> requires ResultType to be movable");
+    static_assert(std::movable<ResultType> || std::same_as<ResultType, void>,
+                  "Task<ResultType> requires ResultType to be movable or void");
 
     public:
+    using result_type = ResultType;
+
     struct promise_type;  // typedef required by coroutines
     using handle_type =
         std::coroutine_handle<promise_type>;  // not required but useful
@@ -97,16 +98,39 @@ class [[nodiscard]] Task {
     template <concepts::HasScheduler T>
     inline handle_type await_suspend(std::coroutine_handle<T> handle) noexcept;
     // Awaitable interface: return result or rethrow exception on resume
-    ResultType await_resume() const;
+    result_type await_resume() const;
 
     private:
     handle_type m_coroutine = nullptr;
 };
 
+// Helper for handling co_return in promise_type, default implementation for
+// non-void ResultType
 template <typename ResultType>
-struct Task<ResultType>::promise_type {
+struct ReturnHelper {
     // Storage for the co_return result value
-    ResultType m_value;
+    std::optional<ResultType> m_value;
+
+    // Required by coroutines, mutually exclusive with return_void
+    // Store the co_return value
+    template <typename T>
+        requires std::constructible_from<ResultType, T&&>
+    void return_value(T&& value) {
+        m_value.emplace(std::forward<T>(value));
+    }
+};
+
+// Specialization for void return type
+template <>
+struct ReturnHelper<void> {
+    // Required by coroutines, mutually exclusive with return_value
+    // Handle co_return without value
+    void return_void() {}
+};
+
+template <typename ResultType>
+struct Task<ResultType>::promise_type
+    : public ReturnHelper<typename Task<ResultType>::result_type> {
     // Storage for exceptions thrown in the coroutine body
     std::exception_ptr m_exception;
     // Handle to the parent coroutine that co_awaited this task
@@ -144,12 +168,6 @@ struct Task<ResultType>::promise_type {
     }
     // Required by coroutines: capture exceptions for later rethrowing
     void unhandled_exception() { m_exception = std::current_exception(); }
-    // Required by coroutines: store the co_return value
-    template <typename T>
-        requires std::assignable_from<ResultType&, T&&>
-    void return_value(T&& value) {
-        m_value = std::forward<T>(value);
-    }
 };
 
 template <typename ResultType>
@@ -162,11 +180,16 @@ inline Task<ResultType>::handle_type Task<ResultType>::await_suspend(
 }
 
 template <typename ResultType>
-inline ResultType Task<ResultType>::await_resume() const {
+inline typename Task<ResultType>::result_type Task<ResultType>::await_resume()
+    const {
     if (m_coroutine.promise().m_exception) {
         std::rethrow_exception(m_coroutine.promise().m_exception);
     }
-    return std::move(m_coroutine.promise().m_value);
+    if constexpr (std::same_as<result_type, void>) {
+        return;
+    } else {
+        return std::move(m_coroutine.promise().m_value).value();
+    }
 }
 }  // namespace CoroutineTests::alien::subtool
 #endif  // COROUTINETESTS_ALIEN_SUBTOOL_H
diff --git a/include/CoroutineTests/alien/tool.hpp b/include/CoroutineTests/alien/tool.hpp
@@ -6,6 +6,7 @@
 #include <exception>
 #include <functional>
 #include <iostream>
+#include <optional>
 
 namespace CoroutineTests::alien::tool {
 
@@ -51,17 +52,17 @@ concept HasScheduler = requires(T t) {
 }  // namespace concepts
 
 // Nestable coroutine, can be co_awaited by other coroutines.
-// Returns a single value of templated type via co_return, doesn't co_yield.
+// Returns a single value of templated type via co_return if it isn't void
+// Doesn't co_yield.
 template <typename ResultType>
 class [[nodiscard]] Task {
 
-    static_assert(
-        std::default_initializable<ResultType>,
-        "Task<ResultType> requires ResultType to be default-initializable");
-    static_assert(std::movable<ResultType>,
-                  "Task<ResultType> requires ResultType to be movable");
+    static_assert(std::movable<ResultType> || std::same_as<ResultType, void>,
+                  "Task<ResultType> requires ResultType to be movable or void");
 
     public:
+    using result_type = ResultType;
+
     struct promise_type;  // typedef required by coroutines
     using handle_type =
         std::coroutine_handle<promise_type>;  // not required but useful
@@ -97,16 +98,39 @@ class [[nodiscard]] Task {
     template <concepts::HasScheduler T>
     inline handle_type await_suspend(std::coroutine_handle<T> handle) noexcept;
     // Awaitable interface: return result or rethrow exception on resume
-    ResultType await_resume() const;
+    result_type await_resume() const;
 
     private:
     handle_type m_coroutine = nullptr;
 };
 
+// Helper for handling co_return in promise_type, default implementation for
+// non-void ResultType
 template <typename ResultType>
-struct Task<ResultType>::promise_type {
+struct ReturnHelper {
     // Storage for the co_return result value
-    ResultType m_value;
+    std::optional<ResultType> m_value;
+
+    // Required by coroutines, mutually exclusive with return_void
+    // Store the co_return value
+    template <typename T>
+        requires std::constructible_from<ResultType, T&&>
+    void return_value(T&& value) {
+        m_value.emplace(std::forward<T>(value));
+    }
+};
+
+// Specialization for void return type
+template <>
+struct ReturnHelper<void> {
+    // Required by coroutines, mutually exclusive with return_value
+    // Handle co_return without value
+    void return_void() {}
+};
+
+template <typename ResultType>
+struct Task<ResultType>::promise_type
+    : public ReturnHelper<typename Task<ResultType>::result_type> {
     // Storage for exceptions thrown in the coroutine body
     std::exception_ptr m_exception;
     // Handle to the parent coroutine that co_awaited this task
@@ -144,12 +168,6 @@ struct Task<ResultType>::promise_type {
     }
     // Required by coroutines: capture exceptions for later rethrowing
     void unhandled_exception() { m_exception = std::current_exception(); }
-    // Required by coroutines: store the co_return value
-    template <typename T>
-        requires std::assignable_from<ResultType&, T&&>
-    void return_value(T&& value) {
-        m_value = std::forward<T>(value);
-    }
 };
 
 template <typename ResultType>
@@ -162,11 +180,16 @@ inline Task<ResultType>::handle_type Task<ResultType>::await_suspend(
 }
 
 template <typename ResultType>
-inline ResultType Task<ResultType>::await_resume() const {
+inline typename Task<ResultType>::result_type Task<ResultType>::await_resume()
+    const {
     if (m_coroutine.promise().m_exception) {
         std::rethrow_exception(m_coroutine.promise().m_exception);
     }
-    return std::move(m_coroutine.promise().m_value);
+    if constexpr (std::same_as<result_type, void>) {
+        return;
+    } else {
+        return std::move(m_coroutine.promise().m_value).value();
+    }
 }
 }  // namespace CoroutineTests::alien::tool
 #endif  // COROUTINETESTS_ALIEN_TOOL_H
