From 50e0108f39fd0230100eb8112a061e2b804c858d Mon Sep 17 00:00:00 2001
From: Khalil Estell <kammce0@gmail.com>
Date: Wed, 14 Jan 2026 14:37:20 -0800
Subject: [PATCH] :recycle: Extract return_void & return_value to their own
 classes

---
 modules/async_context.cppm | 68 ++++++++++++--------------------------
 1 file changed, 22 insertions(+), 46 deletions(-)

diff --git a/modules/async_context.cppm b/modules/async_context.cppm
index ffcafc3..ccc677d 100644
--- a/modules/async_context.cppm
+++ b/modules/async_context.cppm
@@ -819,29 +819,9 @@ struct final_awaiter
   }
 };
 
-export template<typename T>
-class promise : public promise_base
+template<typename T>
+struct promise_return_base
 {
-public:
-  using promise_base::promise_base;  // Inherit constructors
-  using promise_base::operator new;
-  using promise_base::operator delete;
-  using our_handle = std::coroutine_handle<promise<T>>;
-
-  friend class future<T>;
-
-  constexpr final_awaiter<promise<T>> final_suspend() noexcept
-  {
-    return {};
-  }
-
-  void unhandled_exception() noexcept
-  {
-    *m_future_state = std::current_exception();
-  }
-
-  constexpr future<T> get_return_object() noexcept;
-
   template<typename U>
   void return_value(U&& p_value) noexcept
     requires std::is_constructible_v<T, U&&>
@@ -850,40 +830,44 @@ public:
     m_future_state->template emplace<T>(std::forward<U>(p_value));
   }
 
-protected:
   future_state<T>* m_future_state;
 };
 
-export template<>
-class promise<void> : public promise_base
+template<>
+struct promise_return_base<void>
+{
+  void return_void() noexcept
+  {
+    *m_future_state = std::monostate{};
+  }
+
+  future_state<void>* m_future_state;
+};
+
+export template<typename T>
+class promise
+  : public promise_base
+  , public promise_return_base<T>
 {
 public:
   using promise_base::promise_base;  // Inherit constructors
   using promise_base::operator new;
   using promise_base::operator delete;
-  using our_handle = std::coroutine_handle<promise<void>>;
+  using our_handle = std::coroutine_handle<promise<T>>;
 
-  friend class future<void>;
+  friend class future<T>;
 
-  constexpr final_awaiter<promise<void>> final_suspend() noexcept
+  constexpr final_awaiter<promise<T>> final_suspend() noexcept
   {
     return {};
   }
 
-  constexpr future<void> get_return_object() noexcept;
-
   void unhandled_exception() noexcept
   {
-    *m_future_state = std::current_exception();
-  }
-
-  void return_void() noexcept
-  {
-    *m_future_state = std::monostate{};
+    *promise_return_base<T>::m_future_state = std::current_exception();
   }
 
-protected:
-  future_state<void>* m_future_state;
+  constexpr future<T> get_return_object() noexcept;
 };
 
 export template<typename T>
@@ -1101,14 +1085,6 @@ constexpr future<T> promise<T>::get_return_object() noexcept
   return future<T>{ handle };
 }
 
-constexpr future<void> promise<void>::get_return_object() noexcept
-{
-  using future_handle = std::coroutine_handle<promise<void>>;
-  auto handle = future_handle::from_promise(*this);
-  m_context->active_handle(handle);
-  return future<void>{ handle };
-}
-
 void context::unsafe_cancel()
 {
   // TODO(#38): Consider if a safe variant of cancel is achievable