diff --git a/include/ucoro/awaitable.hpp b/include/ucoro/awaitable.hpp
index 132f411..bb9325b 100644
--- a/include/ucoro/awaitable.hpp
+++ b/include/ucoro/awaitable.hpp
@@ -86,6 +86,10 @@ namespace ucoro
 			{ a.await_suspend(std::coroutine_handle<>{}) } -> is_valid_await_suspend_return_value;
 			{ a.await_resume() };
 		};
+		template <typename T>
+		concept is_awaitable_promise_type_v = requires (T a){
+			{ a.local_ } -> std::convertible_to<std::any> ;
+		};
 	} // namespace detail
 
 	struct debug_coro_promise
@@ -160,82 +164,38 @@ namespace ucoro
 	};
 
 	//////////////////////////////////////////////////////////////////////////
-	//
-
-	struct awaitable_promise_base
-		: public debug_coro_promise
+	// 存储协程 promise 的返回值
+	template<typename T>
+	struct awaitable_promise_value
 	{
-		auto initial_suspend()
-		{
-			return std::suspend_always{};
-		}
-
-		template <typename A>
-			requires(detail::is_awaiter_v<std::decay_t<A>>)
-		auto await_transform(A&& awaiter) const
+		template <typename V>
+		void return_value(V &&val) noexcept
 		{
-			static_assert(std::is_rvalue_reference_v<decltype(awaiter)>, "co_await must be used on rvalue");
-			return std::forward<A>(awaiter);
+			value_.template emplace<T>(std::forward<V>(val));
 		}
 
-		template <typename A>
-			requires(!detail::is_awaiter_v<std::decay_t<A>>)
-		auto await_transform(A&& awaiter) const
+		void unhandled_exception() noexcept
 		{
-			return await_transformer<A>::await_transform(std::move(awaiter));
+			value_.template emplace<std::exception_ptr>(std::current_exception());
 		}
 
-		auto await_transform(local_storage_t<void>) noexcept
-		{
-			struct result
-			{
-				awaitable_promise_base *this_;
-
-				constexpr bool await_ready() const noexcept
-				{
-					return true;
-				}
-
-				void await_suspend(std::coroutine_handle<void>) noexcept
-				{
-				}
+		std::variant<std::exception_ptr, T> value_{ nullptr };
+	};
 
-				auto await_resume() const noexcept
-				{
-					return *this_->local_;
-				}
-			};
+	//////////////////////////////////////////////////////////////////////////
+	// 存储协程 promise 的返回值 void 的特化实现
+	template<>
+	struct awaitable_promise_value<void>
+	{
+		std::exception_ptr exception_{ nullptr };
 
-			return result{this};
-		}
+		constexpr void return_void() noexcept { }
 
-		template <typename T>
-		auto await_transform(local_storage_t<T>)
+		void unhandled_exception() noexcept
 		{
-			struct result
-			{
-				awaitable_promise_base *this_;
-
-				constexpr bool await_ready() const noexcept
-				{
-					return true;
-				}
-
-				void await_suspend(std::coroutine_handle<void>) noexcept
-				{
-				}
-
-				auto await_resume()
-				{
-					return std::any_cast<T>(*this_->local_);
-				}
-			};
-
-			return result{this};
+			exception_ = std::current_exception();
 		}
 
-		std::coroutine_handle<> continuation_;
-		std::shared_ptr<std::any> local_;
 	};
 
 	//////////////////////////////////////////////////////////////////////////
@@ -243,7 +203,7 @@ namespace ucoro
 
 	// Promise 类型实现...
 	template <typename T>
-	struct awaitable_promise : public awaitable_promise_base
+	struct awaitable_promise : public awaitable_promise_value<T>, public debug_coro_promise
 	{
 		awaitable<T> get_return_object();
 
@@ -252,43 +212,60 @@ namespace ucoro
 			return final_awaitable<T>{};
 		}
 
-		template <typename V>
-		void return_value(V &&val) noexcept
+		auto initial_suspend()
 		{
-			value_.template emplace<T>(std::forward<V>(val));
+			return std::suspend_always{};
 		}
 
-		void unhandled_exception() noexcept
+		template <typename A>
+			requires (detail::is_awaiter_v<std::decay_t<A>>)
+		auto await_transform(A&& awaiter) const
 		{
-			value_.template emplace<std::exception_ptr>(std::current_exception());
+			static_assert(std::is_rvalue_reference_v<decltype(awaiter)>, "co_await must be used on rvalue");
+			return std::forward<A>(awaiter);
 		}
 
-		std::variant<std::exception_ptr, T> value_{ nullptr };
-	};
-
-	//////////////////////////////////////////////////////////////////////////
-	// 返回 void 的协程偏特化 awaitable_promise 实现
-
-	template <>
-	struct awaitable_promise<void> : public awaitable_promise_base
-	{
-		awaitable<void> get_return_object();
-
-		auto final_suspend() noexcept
+		template <typename A>
+			requires (!detail::is_awaiter_v<std::decay_t<A>>)
+		auto await_transform(A&& awaiter) const
 		{
-			return final_awaitable<void>{};
+			return await_transformer<A>::await_transform(std::move(awaiter));
 		}
 
-		void return_void()
+		void set_local(std::any local)
 		{
+			local_ = std::make_shared<std::any>(local);
 		}
 
-		void unhandled_exception() noexcept
+		template <typename localtype>
+		struct local_storage_awaiter
 		{
-			exception_ = std::current_exception();
+			awaitable_promise *this_;
+
+			constexpr bool await_ready() const noexcept { return true; }
+			void await_suspend(std::coroutine_handle<void>) noexcept {}
+
+			auto await_resume() const noexcept
+			{
+				if constexpr (std::is_void_v<localtype>)
+				{
+					return *this_->local_;
+				}
+				else
+				{
+					return std::any_cast<localtype>(*this_->local_);
+				}
+			}
+		};
+
+		template <typename localtype>
+		auto await_transform(local_storage_t<localtype>)
+		{
+			return local_storage_awaiter<localtype>{this};
 		}
 
-		std::exception_ptr exception_{ nullptr };
+		std::coroutine_handle<> continuation_;
+		std::shared_ptr<std::any> local_;
 	};
 
 	//////////////////////////////////////////////////////////////////////////
@@ -384,20 +361,25 @@ namespace ucoro
 		template <typename PromiseType>
 		auto await_suspend(std::coroutine_handle<PromiseType> continuation)
 		{
-			current_coro_handle_.promise().continuation_ = continuation;
-
-			if constexpr (std::is_base_of_v<awaitable_promise_base, PromiseType>)
+			if constexpr (detail::is_awaitable_promise_type_v<PromiseType>)
 			{
 				current_coro_handle_.promise().local_ = continuation.promise().local_;
 			}
 
+			current_coro_handle_.promise().continuation_ = continuation;
+			return current_coro_handle_;
+		}
+
+		auto await_suspend(std::coroutine_handle<void> continuation)
+		{
+			current_coro_handle_.promise().continuation_ = continuation;
 			return current_coro_handle_;
 		}
 
 		void set_local(std::any local)
 		{
 			assert("local has value" && !current_coro_handle_.promise().local_);
-			current_coro_handle_.promise().local_ = std::make_shared<std::any>(local);
+			current_coro_handle_.promise().set_local(local);
 		}
 
 		void detach()
@@ -428,12 +410,6 @@ namespace ucoro
 		auto result = awaitable<T>{std::coroutine_handle<awaitable_promise<T>>::from_promise(*this)};
 		return result;
 	}
-
-	awaitable<void> awaitable_promise<void>::get_return_object()
-	{
-		auto result = awaitable<void>{std::coroutine_handle<awaitable_promise<void>>::from_promise(*this)};
-		return result;
-	}
 } // namespace ucoro
 
 //////////////////////////////////////////////////////////////////////////