Index: source/ps/Future.h
===================================================================
--- source/ps/Future.h
+++ source/ps/Future.h
@@ -22,7 +22,6 @@
 
 #include <atomic>
 #include <condition_variable>
-#include <functional>
 #include <mutex>
 #include <type_traits>
 
@@ -85,16 +84,16 @@
 };
 
 /**
- * The shared state between futures and packaged state.
- * Holds all relevant data.
+ * The Receiver is responsible for comunicating the result back to the thread
+ * which is waiting on it.
  */
 template<typename ResultType>
-class SharedState final : public SharedStateResult<ResultType>, public ErasedSharedState
+class Receiver : public SharedStateResult<ResultType>
 {
 	static constexpr bool VoidResult = std::is_same_v<ResultType, void>;
 public:
-	SharedState(std::function<ResultType()>&& func) : m_Func(std::move(func)) {}
-	~SharedState()
+	Receiver() = default;
+	~Receiver()
 	{
 		// For safety, wait on started task completion, but not on pending ones (auto-cancelled).
 		if (!Cancel())
@@ -106,21 +105,20 @@
 			SharedStateResult<ResultType>::ResetResult();
 	}
 
-	SharedState(const SharedState&) = delete;
-	SharedState(SharedState&&) = delete;
-
-	void operator()() final
+	template<typename Fun>
+	void Execute(Fun&& function)
 	{
 		Status expected = Status::PENDING;
 		if (!m_Status.compare_exchange_strong(expected, Status::STARTED))
 			return;
 
 		if constexpr (VoidResult)
-			m_Func();
+			std::forward<Fun>(function)();
 		else
 		{
 			// To avoid UB, explicitly placement-new the value.
-			new (&SharedStateResult<ResultType>::m_Result.m_Result) ResultType{m_Func()};
+			new (&SharedStateResult<ResultType>::m_Result.m_Result) ResultType{
+				std::forward<Fun>(function)()};
 			SharedStateResult<ResultType>::m_HasResult = true;
 		}
 
@@ -188,8 +186,33 @@
 	std::atomic<Status> m_Status = Status::PENDING;
 	std::mutex m_Mutex;
 	std::condition_variable m_ConditionVariable;
+};
+
+/**
+ * The SharedState has to stay alive untill the task is finished.
+ */
+template<typename Fun>
+class SharedState final : public ErasedSharedState
+{
+public:
+	SharedState(Fun&& fun) :
+		m_Fun{std::forward<Fun>(fun)}
+	{}
+	~SharedState() = default;
 
-	std::function<ResultType()> m_Func;
+	void operator()() final
+	{
+		m_Recv.Execute(std::forward<Fun>(m_Fun));
+	}
+
+	Receiver<std::invoke_result_t<Fun>>& GetReceiver() noexcept
+	{
+		return m_Recv;
+	}
+
+private:
+	Fun m_Fun;
+	Receiver<std::invoke_result_t<Fun>> m_Recv;
 };
 
 } // namespace FutureSharedStateDetail
@@ -213,7 +236,6 @@
 	static constexpr bool VoidResult = std::is_same_v<ResultType, void>;
 
 	using Status = FutureSharedStateDetail::Status;
-	using SharedState = FutureSharedStateDetail::SharedState<ResultType>;
 public:
 	Future() = default;
 	Future(const Future& o) = delete;
@@ -235,17 +257,17 @@
 	template<typename SfinaeType = ResultType>
 	std::enable_if_t<!std::is_same_v<SfinaeType, void>, ResultType> Get()
 	{
-		ENSURE(!!m_SharedState);
+		ENSURE(!!m_Receiver);
 
 		Wait();
 		if constexpr (VoidResult)
 			return;
 		else
 		{
-			ENSURE(m_SharedState->m_Status != Status::CANCELED);
+			ENSURE(m_Receiver->m_Status != Status::CANCELED);
 
 			// This mark the state invalid - can't call Get again.
-			return m_SharedState->GetResult();
+			return m_Receiver->GetResult();
 		}
 	}
 
@@ -254,7 +276,7 @@
 	 */
 	bool IsReady() const
 	{
-		return !!m_SharedState && m_SharedState->m_Status == Status::DONE;
+		return !!m_Receiver && m_Receiver->m_Status == Status::DONE;
 	}
 
 	/**
@@ -262,13 +284,13 @@
 	 */
 	bool Valid() const
 	{
-		return !!m_SharedState && m_SharedState->m_Status != Status::CANCELED;
+		return !!m_Receiver && m_Receiver->m_Status != Status::CANCELED;
 	}
 
 	void Wait()
 	{
 		if (Valid())
-			m_SharedState->Wait();
+			m_Receiver->Wait();
 	}
 
 	/**
@@ -280,9 +302,9 @@
 	{
 		if (!Valid())
 			return;
-		if (!m_SharedState->Cancel())
-			m_SharedState->Wait();
-		m_SharedState.reset();
+		if (!m_Receiver->Cancel())
+			m_Receiver->Wait();
+		m_Receiver.reset();
 	}
 
 	/**
@@ -292,12 +314,13 @@
 	 */
 	void Cancel()
 	{
-		if (m_SharedState)
-			m_SharedState->Cancel();
-		m_SharedState.reset();
+		if (m_Receiver)
+			m_Receiver->Cancel();
+		m_Receiver.reset();
 	}
-protected:
-	std::shared_ptr<SharedState> m_SharedState;
+private:
+	// Points to the Receiver but manages lifetime of the whole SharedState.
+	std::shared_ptr<FutureSharedStateDetail::Receiver<ResultType>> m_Receiver;
 };
 
 /**
@@ -329,8 +352,10 @@
 {
 	static_assert(std::is_same_v<std::invoke_result_t<T>, ResultType>,
 		"The return type of the wrapped function is not the same as the type of the Future.");
-	m_SharedState = std::make_shared<SharedState>(std::move(func));
-	return PackagedTask{m_SharedState};
+	auto sharedState = std::make_shared<FutureSharedStateDetail::SharedState<T>>(std::forward<T>(func));
+	m_Receiver = std::shared_ptr<FutureSharedStateDetail::Receiver<std::invoke_result_t<T>>>{sharedState,
+		&sharedState->GetReceiver()};
+	return PackagedTask{std::move(sharedState)};
 }
 
 #endif // INCLUDED_FUTURE