core/coroutine: add a specialization for std::expected<void, Err>

include/seastar/core/coroutine.hh

@@ -30,6 +30,9 @@
 
 #ifndef SEASTAR_MODULE
 #include <coroutine>
+#ifdef __cpp_lib_expected
+#include <expected>
+#endif
 #endif
 
 namespace seastar {
@@ -130,6 +133,59 @@ public:
     };
 };
 
+#ifdef __cpp_lib_expected
+template <typename Err>
+class coroutine_traits_base<std::expected<void, Err>> {
+public:
+   class promise_type final : public seastar::task {
+        seastar::promise<std::expected<void, Err>> _promise;
+    public:
+        promise_type() = default;
+        promise_type(promise_type&&) = delete;
+        promise_type(const promise_type&) = delete;
+
+        template<typename... U>
+        void return_value(U&&... value) {
+            _promise.set_value(std::forward<U>(value)...);
+        }
+
+        void return_value(std::expected<void, Err>&& value) {
+            _promise.set_value(std::forward<std::expected<void, Err>>(value));
+        }
+
+        void return_value(coroutine::exception ce) noexcept {
+            _promise.set_exception(std::move(ce.eptr));
+        }
+
+        void set_exception(std::exception_ptr&& eptr) noexcept {
+            _promise.set_exception(std::move(eptr));
+        }
+
+        void unhandled_exception() noexcept {
+            _promise.set_exception(std::current_exception());
+        }
+
+        seastar::future<std::expected<void, Err>> get_return_object() noexcept {
+            return _promise.get_future();
+        }
+
+        std::suspend_never initial_suspend() noexcept { return { }; }
+        std::suspend_never final_suspend() noexcept { return { }; }
+
+        virtual void run_and_dispose() noexcept override {
+            auto handle = std::coroutine_handle<promise_type>::from_promise(*this);
+            handle.resume();
+        }
+
+        task* waiting_task() noexcept override { return _promise.waiting_task(); }
+
+        scheduling_group set_scheduling_group(scheduling_group new_sg) noexcept {
+            return task::set_scheduling_group(new_sg);
+        }
+    };
+};
+#endif
+
 template<bool CheckPreempt, typename T>
 struct awaiter {
     seastar::future<T> _future;

tests/unit/coroutines_test.cc

@@ -1018,3 +1018,17 @@ SEASTAR_TEST_CASE(test_lambda_coroutine_in_continuation) {
     }));
     BOOST_REQUIRE_EQUAL(sin1, sin2);
 }
+
+#ifdef __cpp_lib_expected
+
+future<std::expected<void, std::string>> void_return_expected() {
+  co_return {};
+}
+
+SEASTAR_TEST_CASE(test_std_expected_void_specialization) {
+  auto result = co_await void_return_expected();
+  BOOST_REQUIRE(result.has_value());
+}
+
+#endif
+