Index: source/ps/Future.h
===================================================================
--- source/ps/Future.h
+++ source/ps/Future.h
@@ -48,15 +48,14 @@
  * Holds all relevant data.
  */
 template<typename ResultType>
-class SharedState : public ResultHolder<ResultType>
+class Receiver : public ResultHolder<ResultType>
 {
 	static constexpr bool VoidResult = std::is_same_v<ResultType, void>;
 public:
-	SharedState(std::function<ResultType()>&& func) :
-		ResultHolder<ResultType>{std::nullopt},
-		m_Func(std::move(func))
+	Receiver() :
+		ResultHolder<ResultType>{std::nullopt}
 	{}
-	~SharedState()
+	~Receiver()
 	{
 		// For safety, wait on started task completion, but not on pending ones (auto-cancelled).
 		if (!Cancel())
@@ -66,8 +65,8 @@
 		}
 	}
 
-	SharedState(const SharedState&) = delete;
-	SharedState(SharedState&&) = delete;
+	Receiver(const Receiver&) = delete;
+	Receiver(Receiver&&) = delete;
 
 	bool IsDoneOrCanceled() const
 	{
@@ -122,8 +121,17 @@
 	std::atomic<Status> m_Status = Status::PENDING;
 	std::mutex m_Mutex;
 	std::condition_variable m_ConditionVariable;
+};
+
+template<typename Func>
+struct SharedState
+{
+	SharedState(Func&& func) :
+		m_Func{std::forward<Func>(func)}
+	{}
 
-	std::function<ResultType()> m_Func;
+	Func m_Func{};
+	Receiver<std::invoke_result_t<Func>> m_Recv{};
 };
 
 } // namespace FutureSharedStateDetail
@@ -150,7 +158,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;
@@ -161,8 +168,8 @@
 	/**
 	 * Make the future wait for the result of @a func.
 	 */
-	template<typename T>
-	PackagedTask<ResultType> Wrap(T&& func);
+	template<typename Func>
+	PackagedTask<Func> Wrap(Func&& func);
 
 	/**
 	 * Move the result out of the future, and invalidate the future.
@@ -223,7 +230,7 @@
 	}
 
 protected:
-	std::shared_ptr<SharedState> m_SharedState;
+	std::shared_ptr<FutureSharedStateDetail::Receiver<ResultType>> m_SharedState;
 };
 
 /**
@@ -232,35 +239,39 @@
  * This type is mostly just the shared state and the call operator,
  * handling the promise & continuation logic.
  */
-template<typename ResultType>
+template<typename Func>
 class PackagedTask
 {
-	static constexpr bool VoidResult = std::is_same_v<ResultType, void>;
 public:
 	PackagedTask() = delete;
-	PackagedTask(std::shared_ptr<typename Future<ResultType>::SharedState> ss) : m_SharedState(std::move(ss)) {}
+	PackagedTask(std::shared_ptr<FutureSharedStateDetail::SharedState<Func>> ss) :
+		m_SharedState(std::move(ss))
+	{}
 
 	void operator()()
 	{
-		typename Future<ResultType>::Status expected = Future<ResultType>::Status::PENDING;
-		if (!m_SharedState->m_Status.compare_exchange_strong(expected, Future<ResultType>::Status::STARTED))
+		FutureSharedStateDetail::Status expected = FutureSharedStateDetail::Status::PENDING;
+		if (!m_SharedState->m_Recv.m_Status.compare_exchange_strong(expected,
+			FutureSharedStateDetail::Status::STARTED))
+		{
 			return;
+		}
 
-		if constexpr (VoidResult)
+		if constexpr (std::is_void_v<std::invoke_result_t<Func>>)
 			m_SharedState->m_Func();
 		else
-			m_SharedState->emplace(m_SharedState->m_Func());
+			m_SharedState->m_Recv.emplace(m_SharedState->m_Func());
 
 		// Because we might have threads waiting on us, we need to make sure that they either:
 		// - don't wait on our condition variable
 		// - receive the notification when we're done.
 		// This requires locking the mutex (@see Wait).
 		{
-			std::lock_guard<std::mutex> lock(m_SharedState->m_Mutex);
-			m_SharedState->m_Status = Future<ResultType>::Status::DONE;
+			std::lock_guard<std::mutex> lock(m_SharedState->m_Recv.m_Mutex);
+			m_SharedState->m_Recv.m_Status = FutureSharedStateDetail::Status::DONE;
 		}
 
-		m_SharedState->m_ConditionVariable.notify_all();
+		m_SharedState->m_Recv.m_ConditionVariable.notify_all();
 
 		// We no longer need the shared state, drop it immediately.
 		m_SharedState.reset();
@@ -272,18 +283,19 @@
 		m_SharedState.reset();
 	}
 
-protected:
-	std::shared_ptr<typename Future<ResultType>::SharedState> m_SharedState;
+private:
+	std::shared_ptr<FutureSharedStateDetail::SharedState<Func>> m_SharedState;
 };
 
 template<typename ResultType>
-template<typename T>
-PackagedTask<ResultType> Future<ResultType>::Wrap(T&& func)
+template<typename Func>
+PackagedTask<Func> Future<ResultType>::Wrap(Func&& func)
 {
-	static_assert(std::is_same_v<std::invoke_result_t<T>, ResultType>,
+	static_assert(std::is_same_v<std::invoke_result_t<Func>, 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<ResultType>(m_SharedState);
+	auto temp = std::make_shared<FutureSharedStateDetail::SharedState<Func>>(std::move(func));
+	m_SharedState = std::shared_ptr<FutureSharedStateDetail::Receiver<ResultType>>{temp, &temp->m_Recv};
+	return PackagedTask<Func>(std::move(temp));
 }
 
 #endif // INCLUDED_FUTURE
Index: source/ps/tests/test_Future.h
===================================================================
--- source/ps/tests/test_Future.h
+++ source/ps/tests/test_Future.h
@@ -124,4 +124,21 @@
 		task2();
 		TS_ASSERT_EQUALS(future.Get(), 7);
 	}
+
+	void test_move_only_function()
+	{
+		Future<void> future;
+
+		class MoveOnlyType
+		{
+		public:
+			MoveOnlyType() = default;
+			MoveOnlyType(MoveOnlyType&) = delete;
+			MoveOnlyType& operator=(MoveOnlyType&) = delete;
+			MoveOnlyType(MoveOnlyType&&) = default;
+			MoveOnlyType& operator=(MoveOnlyType&&) = default;
+		};
+
+		future.Wrap([t = MoveOnlyType{}]{});
+	}
 };