diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4870106..c3a6264 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -61,6 +61,8 @@ target_sources(
           src/sled/debugging/demangle.cc
           src/sled/debugging/symbolize.cc
           src/sled/event_bus/event_bus.cc
+          src/sled/futures/future.cc
+          src/sled/futures/internal/failure_handling.cc
           src/sled/filesystem/path.cc
           src/sled/log/log.cc
           src/sled/network/async_resolver.cc
@@ -210,6 +212,7 @@ if(SLED_BUILD_TESTS)
   sled_add_test(NAME sled_inja_test SRCS src/sled/nonstd/inja_test.cc)
   sled_add_test(NAME sled_fsm_test SRCS src/sled/nonstd/fsm_test.cc)
   sled_add_test(NAME sled_timestamp_test SRCS src/sled/units/timestamp_test.cc)
+  sled_add_test(NAME sled_future_test SRCS src/sled/futures/future_test.cc)
   sled_add_test(
     NAME sled_cache_test SRCS src/sled/cache/lru_cache_test.cc
     src/sled/cache/fifo_cache_test.cc src/sled/cache/expire_cache_test.cc)
diff --git a/src/sled/async/async_test.cc b/src/sled/async/async_test.cc
index 4e669dd..892cfe4 100644
--- a/src/sled/async/async_test.cc
+++ b/src/sled/async/async_test.cc
@@ -11,7 +11,7 @@ TEST_SUITE("Async")
             CHECK_EQ(value, 126);
             return value;
         });
-        task1.wait();
+        // task1.wait();
         CHECK_EQ(126, task1.get());
     }
 
diff --git a/src/sled/futures/detail/delay.h b/src/sled/futures/detail/delay.h
deleted file mode 100644
index 5771953..0000000
--- a/src/sled/futures/detail/delay.h
+++ /dev/null
@@ -1,92 +0,0 @@
-#ifndef SLED_FUTURES_DETAIL_DELAY_H
-#define SLED_FUTURES_DETAIL_DELAY_H
-
-#include "sled/units/time_delta.h"
-#include "traits.h"
-#include <exception>
-
-namespace sled {
-namespace detail {
-
-template<typename R>
-struct DelayReceiver {
-    R receiver;
-    sled::TimeDelta delta;
-    bool stopped = false;
-
-    template<typename U>
-    void SetValue(U &&val)
-    {
-        if (stopped) { return; }
-        receiver.SetValue(std::forward<U>(val));
-    }
-
-    void SetError(std::exception_ptr e)
-    {
-        if (stopped) { return; }
-        receiver.SetError(e);
-    }
-
-    void SetStopped()
-    {
-        if (stopped) { return; }
-        stopped = true;
-        receiver.SetStopped();
-    }
-};
-
-template<typename S, typename R>
-struct DelayOperation {
-    ConnectResultT<S, R> op;
-
-    void Start() { op.Start(); }
-
-    void Stop() { op.Stop(); }
-};
-
-template<typename S>
-struct DelaySender {
-    using result_t  = typename S::result_t;
-    using this_type = DelaySender<S>;
-    S sender;
-    sled::TimeDelta delta;
-
-    template<typename R>
-    DelayOperation<S, DelayReceiver<R>> Connect(R receiver)
-    {
-        return {sender.Connect(DelayReceiver<R>{receiver, delta})};
-    }
-
-    template<typename Lazy>
-    friend ContinueResultT<this_type, Lazy> operator|(this_type sender, Lazy lazy)
-    {
-        return lazy.Continue(sender);
-    }
-};
-
-template<typename S>
-DelaySender<S>
-Delay(S sender, sled::TimeDelta const &delta)
-{
-    return {sender, delta};
-}
-
-struct DelayLazy {
-    sled::TimeDelta delta;
-
-    template<typename S>
-    DelaySender<S> Continue(S sender) const
-    {
-        return {sender, delta};
-    }
-};
-
-inline DelayLazy
-Delay(sled::TimeDelta const &delta)
-{
-    return {delta};
-}
-
-}// namespace detail
-}// namespace sled
-#endif//  SLED_FUTURES_DETAIL_DELAY_H
diff --git a/src/sled/futures/detail/future.h b/src/sled/futures/detail/future.h
deleted file mode 100644
index 9d30a7c..0000000
--- a/src/sled/futures/detail/future.h
+++ /dev/null
@@ -1,103 +0,0 @@
-#ifndef SLED_FUTURES_DETAIL_FUTURE_H
-#define SLED_FUTURES_DETAIL_FUTURE_H
-#include "sled/synchronization/mutex.h"
-#include "traits.h"
-
-namespace sled {
-namespace detail {
-
-namespace {
-enum class State {
-    kPending,
-    kError,
-    kValue,
-};
-
-template<typename T>
-struct FutureState {
-
-    sled::Mutex mutex;
-    sled::ConditionVariable cv;
-    State state = State::kPending;
-
-    union {
-        T value;
-        std::exception_ptr error;
-    };
-};
-}// namespace
-
-template<typename R>
-struct FutureOperation {
-    std::shared_ptr<FutureState<typename R::result_t>> state;
-    R receiver;
-    mutable bool stopped = false;
-
-    void Start()
-    {
-        if (stopped) { return; }
-        sled::MutexLock lock(&state->mutex);
-        state->cv.Wait(lock, [&] { return state->state != State::kPending; });
-        if (state->state == State::kValue) {
-            receiver.SetValue(std::move(state->value));
-        } else {
-            receiver.SetError(state->error);
-        }
-    }
-
-    void Stop()
-    {
-        if (stopped) { return; }
-        stopped = true;
-        receiver.SetStopped();
-    }
-};
-
-template<typename T>
-struct FutureSender {
-    using result_t  = T;
-    using this_type = FutureSender<T>;
-    std::shared_ptr<FutureState<T>> state;
-
-    template<typename R>
-    FutureOperation<R> Connect(R receiver)
-    {
-        return {state, receiver};
-    }
-
-    template<typename Lazy>
-    friend ContinueResultT<this_type, Lazy> operator|(this_type sender, Lazy lazy)
-    {
-        return lazy.Continue(sender);
-    }
-};
-
-template<typename T>
-struct Promise {
-    std::shared_ptr<FutureState<T>> state;
-
-    Promise() : state(std::make_shared<FutureState<T>>()) {}
-
-    template<typename U = T>
-    typename std::enable_if<std::is_convertible<U, T>::value>::type SetValue(U &&val)
-    {
-        sled::MutexLock lock(&state->mutex);
-        state->value = std::forward<T>(val);
-        state->state = State::kValue;
-        state->cv.NotifyAll();
-    }
-
-    void SetError(std::exception_ptr e)
-    {
-        sled::MutexLock lock(&state->mutex);
-        state->error = e;
-        state->state = State::kError;
-        state->cv.NotifyAll();
-    }
-
-    FutureSender<T> GetFuture() { return {state}; }
-};
-
-}// namespace detail
-}// namespace sled
-#endif// SLED_FUTURES_DETAIL_FUTURE_H
diff --git a/src/sled/futures/detail/just.h b/src/sled/futures/detail/just.h
deleted file mode 100644
index 4882c0a..0000000
--- a/src/sled/futures/detail/just.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef SLED_FUTURES_DETAIL_JUST_H
-#define SLED_FUTURES_DETAIL_JUST_H
-
-#include "traits.h"
-#include <memory>
-
-namespace sled {
-namespace detail {
-
-template<typename T, typename R>
-struct JustOperation {
-    T value;
-    R receiver;
-
-    void Start() { receiver.SetValue(std::forward<T>(value)); }
-
-    void Stop() { receiver.SetStopped(); }
-};
-
-template<typename T>
-struct JustSender {
-    using result_t  = T;
-    using this_type = JustSender<T>;
-    T value;
-
-    template<typename R>
-    JustOperation<T, R> Connect(R receiver)
-    {
-        return {std::forward<T>(value), receiver};
-    }
-
-    template<typename Lazy>
-    friend ContinueResultT<this_type, Lazy> operator|(this_type sender, Lazy lazy)
-    {
-        return lazy.Continue(sender);
-    }
-};
-
-template<typename T>
-JustSender<T>
-Just(T &&value)
-{
-    return {std::forward<T>(value)};
-}
-
-}// namespace detail
-}// namespace sled
-#endif//  SLED_FUTURES_DETAIL_JUST_H
diff --git a/src/sled/futures/detail/just_test.cc b/src/sled/futures/detail/just_test.cc
deleted file mode 100644
index 39b7b37..0000000
--- a/src/sled/futures/detail/just_test.cc
+++ /dev/null
@@ -1,3 +0,0 @@
-#include <sled/futures/detail/just.h>
-
-TEST(Just, basic) { auto s1 = sled::detail::Just(42); }
diff --git a/src/sled/futures/detail/on.h b/src/sled/futures/detail/on.h
deleted file mode 100644
index 0b9491f..0000000
--- a/src/sled/futures/detail/on.h
+++ /dev/null
@@ -1,114 +0,0 @@
-#ifndef SLED_FUTURES_DETAIL_VIA_H
-#define SLED_FUTURES_DETAIL_VIA_H
-#include "traits.h"
-#include <exception>
-#include <functional>
-#include <memory>
-
-namespace sled {
-namespace detail {
-template<typename R, typename F>
-struct OnReceiver {
-    R receiver;
-    F schedule;
-    bool stopped = false;
-
-    template<typename U>
-    typename std::enable_if<std::is_rvalue_reference<U>::value
-                            || (!std::is_copy_assignable<U>::value && !std::is_copy_constructible<U>::value)>::type
-    SetValue(U &&val)
-    {
-        static_assert(std::is_rvalue_reference<decltype(val)>::value, "U must be an rvalue reference");
-        if (stopped) { return; }
-        try {
-            auto moved = make_move_on_copy(val);
-            schedule([this, moved]() mutable { receiver.SetValue(std::move(moved.value)); });
-        } catch (...) {
-            SetError(std::current_exception());
-        }
-    }
-
-    template<typename U>
-    typename std::enable_if<!std::is_rvalue_reference<U>::value
-                            && (std::is_copy_assignable<U>::value || std::is_copy_constructible<U>::value)>::type
-    SetValue(U &&val)
-    {
-        if (stopped) { return; }
-        try {
-            schedule([this, val] { receiver.SetValue(val); });
-        } catch (...) {
-            SetError(std::current_exception());
-        }
-    }
-
-    void SetError(std::exception_ptr e)
-    {
-        if (stopped) { return; }
-        receiver.SetError(e);
-    }
-
-    void SetStopped()
-    {
-        if (stopped) { return; }
-        stopped = true;
-        receiver.SetStopped();
-    }
-};
-
-template<typename S, typename R>
-struct OnOperation {
-    ConnectResultT<S, R> op;
-
-    void Start() { op.Start(); }
-
-    void Stop() { op.Stop(); }
-};
-
-template<typename S, typename F>
-struct OnSender {
-    using result_t  = typename S::result_t;
-    using this_type = OnSender<S, F>;
-    S sender;
-    F schedule;
-
-    template<typename R>
-    OnOperation<S, OnReceiver<R, F>> Connect(R receiver)
-    {
-        return {sender.Connect(OnReceiver<R, F>{receiver, schedule})};
-    }
-
-    template<typename Lazy>
-    friend ContinueResultT<this_type, Lazy> operator|(this_type sender, Lazy lazy)
-    {
-        return lazy.Continue(sender);
-    }
-};
-
-template<typename F>
-struct OnLazy {
-    F func;
-
-    template<typename S>
-    OnSender<S, F> Continue(S sender) const
-    {
-        return {sender, func};
-    }
-};
-
-template<typename S, typename F>
-OnSender<S, F>
-On(S sender, F &&schedule)
-{
-    return {sender, std::forward<F>(schedule)};
-}
-
-template<typename F>
-OnLazy<F>
-On(F &&schedule)
-{
-    return {schedule};
-}
-
-}// namespace detail
-}// namespace sled
-#endif// SLED_FUTURES_DETAIL_VIA_H
diff --git a/src/sled/futures/detail/retry.h b/src/sled/futures/detail/retry.h
deleted file mode 100644
index 38a4195..0000000
--- a/src/sled/futures/detail/retry.h
+++ /dev/null
@@ -1,144 +0,0 @@
-#ifndef SLED_FUTURES_DETAIL_RETRY_H
-#define SLED_FUTURES_DETAIL_RETRY_H
-
-#include "sled/log/log.h"
-#include "sled/synchronization/mutex.h"
-#include "traits.h"
-#include <memory>
-
-namespace sled {
-namespace detail {
-
-namespace {
-struct RetryState {
-    enum State { kPending, kDone, kRetry };
-
-    sled::Mutex mutex;
-    sled::ConditionVariable cv;
-    int retry_count = 0;
-    State state     = kPending;
-};
-}// namespace
-
-template<typename R>
-struct RetryReceiver {
-    std::shared_ptr<RetryState> state;
-    R receiver;
-    bool stopped = false;
-
-    template<typename U>
-    void SetValue(U &&val)
-    {
-        {
-            sled::MutexLock lock(&state->mutex);
-            if (stopped) { return; }
-            state->state = RetryState::kDone;
-            state->cv.NotifyAll();
-        }
-        receiver.SetValue(std::forward<U>(val));
-    }
-
-    void SetError(std::exception_ptr e)
-    {
-        // notify
-        {
-            sled::MutexLock lock(&state->mutex);
-            if (stopped) { return; }
-            if (state->retry_count > 0) {
-                --state->retry_count;
-                state->state = RetryState::kRetry;
-                return;
-            } else {
-                state->state = RetryState::kDone;
-                state->cv.NotifyAll();
-            }
-        }
-        receiver.SetError(e);
-    }
-
-    void SetStopped()
-    {
-        {
-            sled::MutexLock lock(&state->mutex);
-            if (stopped) { return; }
-            stopped      = true;
-            state->state = RetryState::kDone;
-            state->cv.NotifyAll();
-        }
-        receiver.SetStopped();
-    }
-};
-
-template<typename S, typename R>
-struct RetryOperation {
-    int retry_count;
-    std::shared_ptr<RetryState> state;
-    ConnectResultT<S, R> op;
-
-    void Start()
-    {
-        {
-            sled::MutexLock lock(&state->mutex);
-            state->retry_count = retry_count;
-            state->state       = RetryState::kPending;
-        }
-        do {
-            op.Start();
-            sled::MutexLock lock(&state->mutex);
-            state->cv.Wait(lock, [this] { return state->state != RetryState::kPending; });
-            if (state->state == RetryState::kDone) { break; }
-            state->state = RetryState::kPending;
-        } while (true);
-    }
-
-    void Stop() { op.Stop(); }
-};
-
-template<typename S>
-struct RetrySender {
-    using result_t  = typename S::result_t;
-    using this_type = RetrySender<S>;
-    S sender;
-    int retry_count;
-
-    template<typename R>
-    RetryOperation<S, RetryReceiver<R>> Connect(R receiver)
-    {
-        auto state = std::make_shared<RetryState>();
-        auto op    = sender.Connect(RetryReceiver<R>{state, receiver});
-        return {retry_count, state, op};
-    }
-
-    template<typename Lazy>
-    friend ContinueResultT<this_type, Lazy> operator|(this_type sender, Lazy lazy)
-    {
-        return lazy.Continue(sender);
-    }
-};
-
-template<typename S>
-RetrySender<S>
-Retry(S sender, int retry_count)
-{
-    return {sender, retry_count};
-}
-
-struct RetryLazy {
-    int retry_count;
-
-    template<typename S>
-    RetrySender<S> Continue(S sender) const
-    {
-        return {sender, retry_count};
-    }
-};
-
-inline RetryLazy
-Retry(int retry_count)
-{
-    return {retry_count};
-}
-
-}// namespace detail
-}// namespace sled
-#endif//  SLED_FUTURES_DETAIL_RETRY_H
diff --git a/src/sled/futures/detail/then.h b/src/sled/futures/detail/then.h
deleted file mode 100644
index f1faaac..0000000
--- a/src/sled/futures/detail/then.h
+++ /dev/null
@@ -1,97 +0,0 @@
-#ifndef SLED_FUTURES_DETAIL_THEN_H
-#define SLED_FUTURES_DETAIL_THEN_H
-
-#include "traits.h"
-#include <memory>
-
-namespace sled {
-namespace detail {
-
-template<typename R, typename F>
-struct ThenReceiver {
-    R receiver;
-    F func;
-    bool stopped = false;
-
-    template<typename U, typename Ret = invoke_result_t<F, U>>
-    void SetValue(U &&val)
-    {
-        if (stopped) { return; }
-        try {
-            receiver.SetValue(std::forward<Ret>(func(std::forward<U>(val))));
-        } catch (...) {
-            SetError(std::current_exception());
-        }
-    }
-
-    void SetError(std::exception_ptr e)
-    {
-        if (stopped) { return; }
-        receiver.SetError(e);
-    }
-
-    void SetStopped()
-    {
-        if (stopped) { return; }
-        stopped = true;
-        receiver.SetStopped();
-    }
-};
-
-template<typename S, typename R>
-struct ThenOperation {
-    ConnectResultT<S, R> op;
-
-    void Start() { op.Start(); }
-
-    void Stop() { op.Stop(); }
-};
-
-template<typename S, typename F>
-struct ThenSender {
-    using result_t  = invoke_result_t<F, typename decay_t<S>::result_t>;
-    using this_type = ThenSender<S, F>;
-    S sender;
-    F func;
-
-    template<typename R>
-    ThenOperation<S, ThenReceiver<R, F>> Connect(R receiver)
-    {
-        return {sender.Connect(ThenReceiver<R, F>{receiver, func})};
-    }
-
-    template<typename Lazy>
-    friend ContinueResultT<this_type, Lazy> operator|(this_type sender, Lazy lazy)
-    {
-        return lazy.Continue(sender);
-    }
-};
-
-template<typename S, typename F>
-ThenSender<S, F>
-Then(S &&sender, F &&func)
-{
-    return {std::forward<S>(sender), std::forward<F>(func)};
-}
-
-template<typename F>
-struct ThenLazy {
-    F func;
-
-    template<typename S>
-    ThenSender<S, F> Continue(S sender) const
-    {
-        return {sender, func};
-    }
-};
-
-template<typename F>
-ThenLazy<F>
-Then(F &&func)
-{
-    return {func};
-}
-
-}// namespace detail
-}// namespace sled
-#endif//  SLED_FUTURES_DETAIL_THEN_H
diff --git a/src/sled/futures/detail/traits.h b/src/sled/futures/detail/traits.h
deleted file mode 100644
index 8f42b3a..0000000
--- a/src/sled/futures/detail/traits.h
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef SLED_FUTURES_DETAIL_TRAITS_H
-#define SLED_FUTURES_DETAIL_TRAITS_H
-
-#include "sled/exec/detail/invoke_result.h"
-
-#include <memory>
-#include <type_traits>
-
-namespace sled {
-namespace detail {
-template<typename S, typename R>
-struct ConnectResult {
-    typedef decltype(std::declval<S>().Connect(std::declval<R>())) type;
-};
-
-template<typename S, typename R>
-using ConnectResultT = typename ConnectResult<S, R>::type;
-
-template<typename S, typename Lazy>
-struct ContinueResult {
-    typedef decltype(std::declval<Lazy>().Continue(std::declval<S>())) type;
-};
-
-template<typename S, typename Lazy>
-using ContinueResultT = typename ContinueResult<S, Lazy>::type;
-
-template<typename F, typename... Args>
-using invoke_result_t = eggs::invoke_result_t<F, Args...>;
-
-template<typename T>
-using decay_t = typename std::decay<T>::type;
-
-template<typename T>
-struct move_on_copy {
-    using type = typename std::remove_reference<T>::type;
-
-    move_on_copy(type &&value) : value(std::move(value)) {}
-
-    move_on_copy(const move_on_copy &other) : value(std::move(other.value)) {}
-
-    move_on_copy(move_on_copy &&)                 = delete;
-    move_on_copy &operator=(const move_on_copy &) = delete;
-
-    mutable type value;
-};
-
-template<typename T>
-move_on_copy<T>
-make_move_on_copy(T &&value)
-{
-    return {std::move<T>(value)};
-}
-
-}// namespace detail
-}// namespace sled
-#endif// SLED_FUTURES_DETAIL_TRAITS_H
diff --git a/src/sled/futures/future.cc b/src/sled/futures/future.cc
new file mode 100644
index 0000000..036b561
--- /dev/null
+++ b/src/sled/futures/future.cc
@@ -0,0 +1,15 @@
+
+#include "sled/futures/future.h"
+
+namespace sled {
+namespace detail {
+void
+IncrementFuturesUsage()
+{}
+
+void
+DecrementFuturesUsage()
+{}
+
+}// namespace detail
+}// namespace sled
diff --git a/src/sled/futures/future.h b/src/sled/futures/future.h
index a21378b..712b18e 100644
--- a/src/sled/futures/future.h
+++ b/src/sled/futures/future.h
@@ -1,6 +1,327 @@
 #ifndef SLED_FUTURES_FUTURE_H
 #define SLED_FUTURES_FUTURE_H
 
-namespace sled {}
+#pragma once
+#include "sled/futures/internal/failure_handling.h"
+#include "sled/futures/internal/promise.h"
+#include "sled/lang/attributes.h"
+#include "sled/log/log.h"
+#include "sled/synchronization/event.h"
+#include "sled/synchronization/mutex.h"
+#include "sled/variant.h"
+#include <atomic>
+#include <list>
 
-#endif//  SLED_FUTURES_FUTURE_H
+namespace sled {
+namespace detail {
+template<typename F, typename... Args>
+struct is_invocable : std::is_constructible<std::function<void(Args...)>,
+                                            std::reference_wrapper<typename std::remove_reference<F>::type>> {};
+
+template<typename R, typename F, typename... Args>
+struct is_invocable_r : std::is_constructible<std::function<R(Args...)>,
+                                              std::reference_wrapper<typename std::remove_reference<F>::type>> {};
+
+enum FutureState {
+    kNotCompletedFuture = 0,
+    kSuccessFuture      = 1,
+    kFailedFuture       = 2,
+};
+
+SLED_EXPORT void IncrementFuturesUsage();
+SLED_EXPORT void DecrementFuturesUsage();
+
+template<typename T, typename FailureT>
+struct FutureData {
+    FutureData() { IncrementFuturesUsage(); }
+
+    FutureData(const FutureData &)            = delete;
+    FutureData(FutureData &&)                 = delete;
+    FutureData &operator=(const FutureData &) = delete;
+    FutureData &operator=(FutureData &&)      = delete;
+
+    ~FutureData() { DecrementFuturesUsage(); }
+
+    std::atomic_int state{kNotCompletedFuture};
+    sled::variant<sled::monostate, T, FailureT> value;
+    std::list<std::function<void(const T &)>> success_callbacks;
+    std::list<std::function<void(const FailureT &)>> failure_callbacks;
+    sled::Mutex mutex_;
+};
+}// namespace detail
+
+//
+
+template<typename T, typename FailureT>
+class Future {
+    static_assert(!std::is_same<T, void>::value, "Future<void, _> is not allowed. Use Future<bool, _> instead");
+    static_assert(!std::is_same<FailureT, void>::value, "Future<_, void> is not allowed. Use Future<_, bool> instead");
+    template<typename T2, typename FailureT2>
+    friend class Future;
+    friend class Promise<T, FailureT>;
+    friend struct detail::FutureData<T, FailureT>;
+
+public:
+    using Value   = T;
+    using Failure = FailureT;
+
+    Future() noexcept = default;
+
+    explicit Future(const Promise<T, FailureT> &promise) { data_ = promise.future().data_; }
+
+    Future(const Future<T, FailureT> &) noexcept                         = default;
+    Future(Future<T, FailureT> &&) noexcept                              = default;
+    Future<T, FailureT> &operator=(const Future<T, FailureT> &) noexcept = default;
+    Future<T, FailureT> &operator=(Future<T, FailureT> &&) noexcept      = default;
+    ~Future()                                                            = default;
+
+    bool operator==(const Future<T, FailureT> &other) const noexcept { return data_ == other.data_; }
+
+    bool operator!=(const Future<T, FailureT> &other) const noexcept { return !operator==(other); }
+
+    bool IsCompleted() const noexcept
+    {
+        SLED_ASSERT(data_ != nullptr, "Future is not valid");
+        int value = data_->state.load(std::memory_order_acquire);
+        return value == detail::kSuccessFuture || value == detail::kFailedFuture;
+    }
+
+    bool IsFailed() const noexcept
+    {
+        SLED_ASSERT(data_ != nullptr, "Future is not valid");
+        return data_->state.load(std::memory_order_acquire) == detail::kFailedFuture;
+    }
+
+    bool IsSucceeded() const noexcept
+    {
+        SLED_ASSERT(data_ != nullptr, "Future is not valid");
+        return data_->state.load(std::memory_order_acquire) == detail::kSuccessFuture;
+    }
+
+    bool IsValid() const noexcept { return static_cast<bool>(data_); }
+
+    bool Wait(int64_t timeout_ms) const noexcept { return Wait(sled::TimeDelta::Millis(timeout_ms)); }
+
+    bool Wait(sled::TimeDelta timeout = sled::Event::kForever) const noexcept
+    {
+        SLED_ASSERT(data_ != nullptr, "Future is not valid");
+        if (IsCompleted()) { return true; }
+
+        bool wait_forever         = timeout <= sled::TimeDelta::Zero();
+        sled::TimeDelta wait_time = wait_forever ? sled::Event::kForever : timeout;
+
+        auto event_ptr = std::make_shared<sled::Event>();
+        OnComplete([event_ptr]() { event_ptr->Set(); });
+        event_ptr->Wait(wait_time);
+
+        return IsCompleted();
+    }
+
+    template<typename Dummy = void,
+             typename       = typename std::enable_if<std::is_copy_constructible<T>::value, Dummy>::type>
+    T Result() const noexcept
+    {
+        SLED_ASSERT(data_ != nullptr, "Future is not valid");
+        if (!IsCompleted()) Wait();
+        if (IsSucceeded()) {
+            try {
+                return sled::get<T>(data_->value);
+            } catch (...) {}
+        }
+        return T();
+    }
+
+    const T &ResultRef() const
+    {
+        SLED_ASSERT(data_ != nullptr, "Future is not valid");
+        if (!IsCompleted()) { Wait(); }
+        return sled::get<T>(data_->value);
+    }
+
+    FailureT FailureReason() const
+    {
+        SLED_ASSERT(data_ != nullptr, "Future is not valid");
+        if (!IsCompleted()) { Wait(); }
+        if (IsFailed()) {
+            try {
+                return sled::get<FailureT>(data_->value);
+            } catch (...) {}
+        }
+        return FailureT();
+    }
+
+    template<typename Func, typename = typename std::enable_if<detail::is_invocable<Func, T>::value>::type>
+    Future<T, FailureT> OnSuccess(Func &&f) const noexcept
+    {
+        SLED_ASSERT(data_ != nullptr, "Future is not valid");
+        bool call_it = false;
+        {
+            sled::MutexLock lock(&data_->mutex_);
+            if (IsCompleted()) {
+                call_it = IsSucceeded();
+            } else {
+                try {
+                    data_->success_callbacks.emplace_back(std::forward<Func>(f));
+                } catch (std::exception &e) {
+                    return Future<T, FailureT>::Failed(detail::ExceptionFailure<FailureT>(e));
+                } catch (...) {
+                    return Future<T, FailureT>::Failed(detail::ExceptionFailure<FailureT>());
+                }
+            }
+        }
+        if (call_it) {
+            try {
+                f(sled::get<T>(data_->value));
+            } catch (...) {}
+        }
+        return Future<T, FailureT>(data_);
+    }
+
+    template<typename Func, typename = typename std::enable_if<detail::is_invocable<Func, FailureT>::value>::type>
+    Future<T, FailureT> OnFailure(Func &&f) const noexcept
+    {
+        SLED_ASSERT(data_ != nullptr, "Future is not valid");
+        bool call_it = false;
+        {
+            sled::MutexLock lock(&data_->mutex_);
+            if (IsCompleted()) {
+                call_it = IsFailed();
+            } else {
+                try {
+                    data_->failure_callbacks.emplace_back(std::forward<Func>(f));
+                } catch (std::exception &e) {
+                    return Future<T, FailureT>::Failed(detail::ExceptionFailure<FailureT>(e));
+                } catch (...) {
+                    return Future<T, FailureT>::Failed(detail::ExceptionFailure<FailureT>());
+                }
+            }
+        }
+        if (call_it) {
+            try {
+                f(sled::get<FailureT>(data_->value));
+            } catch (...) {}
+        }
+        return Future<T, FailureT>(data_);
+    }
+
+    template<typename Func, typename = typename std::enable_if<detail::is_invocable<Func>::value>::type>
+    Future<T, FailureT> OnComplete(Func &&f) const noexcept
+    {
+        SLED_ASSERT(data_ != nullptr, "Future is not valid");
+        OnSuccess([f](const T &) noexcept { f(); });
+        OnFailure([f](const FailureT &) noexcept { f(); });
+        return Future<T, FailureT>(data_);
+    }
+
+    // template<typename Func, typename = typename std::enable_if<detail::is_invocable<Func>::value>::type>
+    // Future<T, FailureT> OnComplete(Func &&F) const noexcept
+    // {
+    //     SLED_ASSERT(data_ != nullptr, "Future is not valid");
+    //     OnSuccess([f](const auto &) noexcept { f(); })
+    // }
+
+    static Future<typename std::decay<T>::type, FailureT> Successful(T &&value) noexcept
+    {
+        Future<typename std::decay<T>::type, FailureT> result
+            = Future<typename std::decay<T>::type, FailureT>::Create();
+        result.FillSuccess(std::forward<T>(value));
+        return result;
+    }
+
+    static Future<T, FailureT> successful(const T &value) noexcept
+    {
+        Future<T, FailureT> result = Future<T, FailureT>::Create();
+        result.FillSuccess(value);
+        return result;
+    }
+
+    static Future<T, FailureT> Successful() { return Future<T, FailureT>::Successful(T()); }
+
+    static Future<T, FailureT> Failed(const FailureT &failure) noexcept
+    {
+        Future<T, FailureT> result = Future<T, FailureT>::Create();
+        result.FillFailure(failure);
+        return result;
+    }
+
+private:
+    explicit Future(std::shared_ptr<detail::FutureData<T, FailureT>> other_data) { data_ = other_data; }
+
+    inline static Future<T, FailureT> Create()
+    {
+        Future<T, FailureT> result;
+        result.data_ = std::make_shared<detail::FutureData<T, FailureT>>();
+        return result;
+    }
+
+    void FillSuccess(const T &value)
+    {
+        T copy = value;
+        FillSuccess(std::move(copy));
+    }
+
+    void FillSuccess(T &&value)
+    {
+        SLED_ASSERT(data_ != nullptr, "Future is not valid");
+        if (detail::HasLastFailure()) {
+            FailureT failure = detail::LastFailure<FailureT>();
+            detail::InvalidateLastFailure();
+            FillFailure(std::move(failure));
+            return;
+        }
+
+        std::list<std::function<void(const T &)>> callbacks;
+        {
+            sled::MutexLock lock(&data_->mutex_);
+            if (IsCompleted()) { return; }
+
+            try {
+                data_->value.template emplace<T>(std::move(value));
+            } catch (...) {}
+            data_->state.store(detail::kSuccessFuture, std::memory_order_release);
+            callbacks                = std::move(data_->success_callbacks);
+            data_->success_callbacks = std::list<std::function<void(const T &)>>();
+            data_->failure_callbacks.clear();
+        }
+
+        for (const auto &f : callbacks) {
+            try {
+                f(sled::get<T>(data_->value));
+            } catch (...) {}
+        }
+    }
+
+    void FillFailure(const FailureT &reason)
+    {
+        FailureT copy = reason;
+        FillFailure(std::move(copy));
+    }
+
+    void FillFailure(FailureT &&reason)
+    {
+        SLED_ASSERT(data_ != nullptr, "Future is not valid");
+        std::list<std::function<void(const FailureT &)>> callbacks;
+        {
+            sled::MutexLock lock(&data_->mutex_);
+            if (IsCompleted()) { return; }
+            try {
+                data_->value.template emplace<FailureT>(std::move(reason));
+            } catch (...) {}
+            data_->state.store(detail::kFailedFuture, std::memory_order_release);
+            callbacks                = std::move(data_->failure_callbacks);
+            data_->failure_callbacks = std::list<std::function<void(const FailureT &)>>();
+            data_->success_callbacks.clear();
+        }
+
+        for (const auto &f : callbacks) {
+            try {
+                f(sled::get<FailureT>(data_->value));
+            } catch (...) {}
+        }
+    }
+
+    std::shared_ptr<detail::FutureData<T, FailureT>> data_;
+};
+}// namespace sled
+
+#endif// SLED_FUTURES_FUTURE_H
diff --git a/src/sled/futures/future_test.cc b/src/sled/futures/future_test.cc
new file mode 100644
index 0000000..f90d9a0
--- /dev/null
+++ b/src/sled/futures/future_test.cc
@@ -0,0 +1,26 @@
+#include <sled/futures/future.h>
+
+TEST_SUITE("future")
+{
+    TEST_CASE("base success")
+    {
+        sled::Promise<int, std::string> p;
+        auto f = p.GetFuture();
+        p.Success(42);
+        CHECK(f.Wait(-1));
+        CHECK(f.IsValid());
+        CHECK_EQ(f.Result(), 42);
+    }
+    TEST_CASE("base failed")
+    {
+        sled::Promise<int, std::string> p;
+        auto f = p.GetFuture();
+        p.Failure("error");
+        REQUIRE(p.IsFilled());
+        REQUIRE(f.IsCompleted());
+        CHECK(f.Wait(-1));
+        CHECK(f.IsValid());
+        CHECK_EQ(f.FailureReason(), "error");
+    }
+    TEST_CASE("thread success") {}
+}
diff --git a/src/sled/futures/internal/failure_handling.cc b/src/sled/futures/internal/failure_handling.cc
new file mode 100644
index 0000000..0ca392d
--- /dev/null
+++ b/src/sled/futures/internal/failure_handling.cc
@@ -0,0 +1,32 @@
+#include "sled/futures/internal/failure_handling.h"
+
+namespace sled {
+namespace detail {
+static thread_local sled::any last_failure;
+
+bool
+HasLastFailure() noexcept
+{
+    return last_failure.has_value();
+}
+
+void
+InvalidateLastFailure() noexcept
+{
+    last_failure.reset();
+}
+
+const sled::any &
+LastFailureAny() noexcept
+{
+    return last_failure;
+}
+
+void
+SetLastFailure(const sled::any &failure) noexcept
+{
+    last_failure = failure;
+}
+
+}// namespace detail
+}// namespace sled
diff --git a/src/sled/futures/internal/failure_handling.h b/src/sled/futures/internal/failure_handling.h
new file mode 100644
index 0000000..14977e6
--- /dev/null
+++ b/src/sled/futures/internal/failure_handling.h
@@ -0,0 +1,108 @@
+#ifndef SLED_FUTURES_INTERNAL_FAILURE_HANDLING_H
+#define SLED_FUTURES_INTERNAL_FAILURE_HANDLING_H
+
+#pragma once
+#include "sled/any.h"
+#include <string>
+
+namespace sled {
+namespace failure {
+template<typename FailureT>
+inline FailureT
+FailureFromString(std::string &&)
+{
+    return FailureT();
+}
+
+template<typename FailureT>
+inline FailureT
+FailureFromString(const std::string &str)
+{
+    std::string copy = str;
+    return FailureFromString<FailureT>(std::move(copy));
+}
+
+template<>
+inline std::string
+FailureFromString<std::string>(std::string &&str)
+{
+    return std::move(str);
+}
+
+}// namespace failure
+
+namespace detail {
+bool HasLastFailure() noexcept;
+void InvalidateLastFailure() noexcept;
+const sled::any &LastFailureAny() noexcept;
+void SetLastFailure(const sled::any &) noexcept;
+
+template<typename FailureT>
+inline FailureT
+LastFailure() noexcept
+{
+    if (!HasLastFailure()) { return FailureT(); }
+    try {
+        return sled::any_cast<FailureT>(LastFailureAny());
+    } catch (...) {
+        return FailureT();
+    }
+}
+
+template<typename FailureT>
+inline void
+SetLastFailure(const FailureT &failure) noexcept
+{
+    SetLastFailure(sled::any(failure));
+}
+
+template<typename FailureT>
+FailureT
+ExceptionFailure(const std::exception &e)
+{
+    return failure::FailureFromString<FailureT>(e.what());
+}
+
+template<typename FailureT>
+FailureT
+ExceptionFailure()
+{
+    return failure::FailureFromString<FailureT>("Exception");
+}
+}// namespace detail
+
+template<typename T, typename FailureT>
+class Future;
+
+template<typename FailureT>
+struct WithFuture {
+    explicit WithFuture(const FailureT &f = FailureT()) noexcept : failure_(f) {}
+
+    explicit WithFuture(FailureT &&f) noexcept : failure_(std::move(f)) {}
+
+    template<typename... Args>
+    explicit WithFuture(Args &&...args) noexcept : failure_(std::forward<Args>(args)...)
+    {}
+
+    template<typename T>
+    operator T() const noexcept
+    {
+        detail::SetLastFailure(std::move(failure_));
+        return T();
+    }
+
+    template<typename T>
+    operator Future<T, FailureT>() noexcept
+    {
+        Future<T, FailureT> result = Future<T, FailureT>::Create();
+        result.Faillure(failure_);
+        return result;
+    }
+
+private:
+    FailureT failure_;
+};
+
+}// namespace sled
+
+#endif// SLED_FUTURES_INTERNAL_FAILURE_HANDLING_H
diff --git a/src/sled/futures/internal/promise.h b/src/sled/futures/internal/promise.h
new file mode 100644
index 0000000..8c73a62
--- /dev/null
+++ b/src/sled/futures/internal/promise.h
@@ -0,0 +1,43 @@
+#ifndef SLED_FUTURES_INTERNAL_PROMISE_H
+#define SLED_FUTURES_INTERNAL_PROMISE_H
+
+#pragma once
+
+#include <memory>
+#include <type_traits>
+
+namespace sled {
+template<typename T, typename FailureT>
+class Future;
+
+template<typename T, typename FailureT>
+class Promise {
+    static_assert(!std::is_same<T, void>::value, "Promise<void, _> is not allowed. Use Promise<bool, _> instead");
+    static_assert(!std::is_same<FailureT, void>::value,
+                  "Promise<_, void> is not allowed. Use Promise<_, bool> instead");
+
+public:
+    using Value                                  = T;
+    Promise()                                    = default;
+    Promise(const Promise &) noexcept            = default;
+    Promise(Promise &&) noexcept                 = default;
+    Promise &operator=(const Promise &) noexcept = default;
+    Promise &operator=(Promise &&) noexcept      = default;
+    ~Promise()                                   = default;
+
+    Future<T, FailureT> GetFuture() const { return future_; };
+
+    bool IsFilled() const noexcept { return future_.IsCompleted(); }
+
+    void Failure(const FailureT &reason) { return future_.FillFailure(reason); }
+
+    void Success(const T &value) { return future_.FillSuccess(value); }
+
+    void Success(T &&value) { return future_.FillSuccess(std::move(value)); }
+
+private:
+    Future<T, FailureT> future_ = Future<T, FailureT>::Create();
+};
+}// namespace sled
+
+#endif// SLED_FUTURES_INTERNAL_PROMISE_H
diff --git a/src/sled/futures/promise.h b/src/sled/futures/promise.h
deleted file mode 100644
index e869167..0000000
--- a/src/sled/futures/promise.h
+++ /dev/null
@@ -1,1438 +0,0 @@
-/*******************************************************************************
- * This file is part of the "https://github.com/blackmatov/promise.hpp"
- * For conditions of distribution and use, see copyright notice in LICENSE.md
- * Copyright (C) 2018-2023, by Matvey Cherevko (blackmatov@gmail.com)
- ******************************************************************************/
-
-#ifndef SLED_FUTURES_PROMISE_H
-#define SLED_FUTURES_PROMISE_H
-#pragma once
-#include "sled/exec/detail/invoke_result.h"
-#include "sled/synchronization/mutex.h"
-
-#include <cassert>
-#include <cstdint>
-
-#include <atomic>
-#include <chrono>
-#include <condition_variable>
-#include <exception>
-#include <functional>
-#include <iterator>
-#include <memory>
-#include <mutex>
-#include <new>
-#include <stdexcept>
-#include <thread>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-namespace promise_hpp {
-//
-// forward declaration
-//
-
-template<typename T = void>
-class promise;
-
-//
-// is_promise
-//
-
-namespace impl {
-template<typename T>
-struct is_promise_impl : std::false_type {};
-
-template<typename R>
-struct is_promise_impl<promise<R>> : std::true_type {};
-}// namespace impl
-
-template<typename T>
-struct is_promise : impl::is_promise_impl<typename std::remove_cv<T>::type> {};
-
-template<typename T>
-constexpr bool is_promise_v = is_promise<T>::value;
-
-//
-// is_promise_r
-//
-
-namespace impl {
-template<typename R, typename T>
-struct is_promise_r_impl : std::false_type {};
-
-template<typename R, typename PR>
-struct is_promise_r_impl<R, promise<PR>> : std::is_convertible<PR, R> {};
-}// namespace impl
-
-template<typename R, typename T>
-struct is_promise_r : impl::is_promise_r_impl<R, std::remove_cv_t<T>> {};
-
-template<typename R, typename T>
-constexpr bool is_promise_r_v = is_promise_r<R, T>::value;
-
-//
-// promise_wait_status
-//
-
-enum class promise_wait_status { no_timeout, timeout };
-
-//
-// aggregate_exception
-//
-
-class aggregate_exception final : public std::exception {
-private:
-    using exceptions_t = std::vector<std::exception_ptr>;
-    using internal_state_t = std::shared_ptr<exceptions_t>;
-
-public:
-    aggregate_exception() : state_(std::make_shared<exceptions_t>()) {}
-
-    explicit aggregate_exception(exceptions_t exceptions)
-        : state_(std::make_shared<exceptions_t>(std::move(exceptions)))
-    {}
-
-    aggregate_exception(const aggregate_exception &other) noexcept : state_(other.state_) {}
-
-    aggregate_exception &operator=(const aggregate_exception &other) noexcept
-    {
-        if (this != &other) { state_ = other.state_; }
-        return *this;
-    }
-
-    const char *what() const noexcept override { return "Aggregate exception"; }
-
-    bool empty() const noexcept { return (*state_).empty(); }
-
-    std::size_t size() const noexcept { return (*state_).size(); }
-
-    std::exception_ptr at(std::size_t index) const { return (*state_).at(index); }
-
-    std::exception_ptr operator[](std::size_t index) const noexcept { return (*state_)[index]; }
-
-private:
-    internal_state_t state_;
-};
-}// namespace promise_hpp
-
-// -----------------------------------------------------------------------------
-//
-// detail
-//
-// -----------------------------------------------------------------------------
-
-namespace promise_hpp {
-namespace detail {
-template<typename T>
-void
-destroy_in_place(T &ref) noexcept
-{
-    ref.~T();
-}
-
-template<typename T, typename... Args>
-void
-construct_in_place(T &ref, Args &&...args) noexcept(std::is_nothrow_constructible<T, Args...>::value)
-{
-    ::new (std::addressof(ref)) T(std::forward<Args>(args)...);
-}
-
-class noncopyable {
-public:
-    noncopyable(const noncopyable &) = delete;
-    noncopyable &operator=(const noncopyable &) = delete;
-
-protected:
-    noncopyable() = default;
-    ~noncopyable() = default;
-};
-
-template<typename T>
-class storage final : private noncopyable {
-public:
-    storage() = default;
-
-    ~storage() noexcept
-    {
-        if (initialized_) { destroy_in_place(*ptr_()); }
-    }
-
-    storage &operator=(T &&value) noexcept(std::is_nothrow_move_constructible<T>::value)
-    {
-        assert(!initialized_);
-        construct_in_place(*ptr_(), std::move(value));
-        initialized_ = true;
-        return *this;
-    }
-
-    storage &operator=(const T &value) noexcept(std::is_nothrow_copy_constructible<T>::value)
-    {
-        assert(!initialized_);
-        construct_in_place(*ptr_(), value);
-        initialized_ = true;
-        return *this;
-    }
-
-    T &operator*() noexcept
-    {
-        assert(initialized_);
-        return *ptr_();
-    }
-
-    const T &operator*() const noexcept
-    {
-        assert(initialized_);
-        return *ptr_();
-    }
-
-private:
-    T *ptr_() noexcept { return reinterpret_cast<T *>(&data_); }
-
-    const T *ptr_() const noexcept { return reinterpret_cast<const T *>(&data_); }
-
-private:
-    std::aligned_storage_t<sizeof(T), alignof(T)> data_;
-    bool initialized_ = false;
-};
-
-template<typename T>
-class storage<T &> final : private noncopyable {
-public:
-    storage() = default;
-    ~storage() = default;
-
-    storage &operator=(T &value) noexcept
-    {
-        assert(!initialized_);
-        value_ = &value;
-        initialized_ = true;
-        return *this;
-    }
-
-    T &operator*() noexcept
-    {
-        assert(initialized_);
-        return *value_;
-    }
-
-    const T &operator*() const noexcept
-    {
-        assert(initialized_);
-        return *value_;
-    }
-
-private:
-    T *value_{nullptr};
-    bool initialized_ = false;
-};
-}// namespace detail
-}// namespace promise_hpp
-
-// -----------------------------------------------------------------------------
-//
-// promise<T>
-//
-// -----------------------------------------------------------------------------
-
-namespace promise_hpp {
-
-template<typename T>
-class promise final {
-public:
-    using value_type = T;
-
-    promise() : state_(std::make_shared<state>()) {}
-
-    promise(promise &&) = default;
-    promise &operator=(promise &&) = default;
-
-    promise(const promise &) = default;
-    promise &operator=(const promise &) = default;
-
-    void swap(promise &other) noexcept { state_.swap(other.state_); }
-
-    std::size_t hash() const noexcept { return std::hash<state *>()(state_.get()); }
-
-    friend bool operator<(const promise &l, const promise &r) noexcept { return l.state_ < r.state_; }
-
-    friend bool operator==(const promise &l, const promise &r) noexcept { return l.state_ == r.state_; }
-
-    friend bool operator!=(const promise &l, const promise &r) noexcept { return l.state_ != r.state_; }
-
-    promise GetFuture() const { return promise(*this); }
-
-    //
-    // get
-    //
-
-    const T &Get() const { return state_->Get(); }
-
-    template<typename U>
-    T GetOr(U &&def) const
-    {
-        try {
-            return Get();
-        } catch (...) {
-            return std::forward<U>(def);
-        }
-    }
-
-    //
-    // wait
-    //
-
-    void Wait() const noexcept { state_->Wait(); }
-
-    inline promise_wait_status WaitFor(const sled::TimeDelta &timeout_duration) const
-    {
-        return state_->wait_for(std::chrono::microseconds(timeout_duration.us()));
-    }
-
-    template<typename Rep, typename Period>
-    promise_wait_status WaitFor(const std::chrono::duration<Rep, Period> &timeout_duration) const
-    {
-        return state_->WaitFor(timeout_duration);
-    }
-
-    template<typename Clock, typename Duration>
-    promise_wait_status WaitUntil(const std::chrono::time_point<Clock, Duration> &timeout_time) const
-    {
-        return state_->WaitUntil(timeout_time);
-    }
-
-    //
-    // resolve/reject
-    //
-
-    template<typename U>
-    bool Resolve(U &&value)
-    {
-        return state_->Resolve(std::forward<U>(value));
-    }
-
-    bool Reject(std::exception_ptr e) noexcept { return state_->Reject(e); }
-
-    template<typename E>
-    bool Reject(E &&e)
-    {
-        return state_->Reject(std::make_exception_ptr(std::forward<E>(e)));
-    }
-
-    //
-    // then
-    //
-
-    template<typename ResolveF, typename ResolveR = eggs::invoke_result_t<ResolveF, T>>
-    std::enable_if_t<is_promise_v<ResolveR>, promise<typename ResolveR::value_type>> Then(ResolveF &&on_resolve)
-    {
-        promise<typename ResolveR::value_type> next;
-
-        Then([n = next, f = std::forward<ResolveF>(on_resolve)](auto &&v) mutable {
-            // auto np = eggs::invoke(std::forward<decltype(f)>(f), std::forward<decltype(v)>(v));
-            auto np = eggs::invoke(std::forward<decltype(f)>(f), std::forward<decltype(v)>(v));
-            std::move(np)
-                .then([n](auto &&...nvs) mutable { n.resolve(std::forward<decltype(nvs)>(nvs)...); })
-                .except([n](std::exception_ptr e) mutable { n.reject(e); });
-        }).except([n = next](std::exception_ptr e) mutable { n.reject(e); });
-
-        return next;
-    }
-
-    template<typename TapF>
-    auto Tap(TapF &&on_tap)
-    {
-        return Then([f = std::forward<TapF>(on_tap)](auto &&v) mutable {
-            eggs::invoke(std::forward<decltype(f)>(f), const_cast<const decltype(v)>(v));
-            return std::forward<decltype(v)>(v);
-        });
-    }
-
-    template<typename ResolveF>
-    auto ThenAll(ResolveF &&on_resolve)
-    {
-        return Then([f = std::forward<ResolveF>(on_resolve)](auto &&v) mutable {
-            auto r = eggs::invoke(std::forward<decltype(f)>(f), std::forward<decltype(v)>(v));
-            return make_all_promise(std::move(r));
-        });
-    }
-
-    template<typename ResolveF>
-    auto ThenAny(ResolveF &&on_resolve)
-    {
-        return Then([f = std::forward<ResolveF>(on_resolve)](auto &&v) mutable {
-            auto r = eggs::invoke(std::forward<decltype(f)>(f), std::forward<decltype(v)>(v));
-            return make_any_promise(std::move(r));
-        });
-    }
-
-    template<typename ResolveF>
-    auto ThenRace(ResolveF &&on_resolve)
-    {
-        return Then([f = std::forward<ResolveF>(on_resolve)](auto &&v) mutable {
-            auto r = eggs::invoke(std::forward<decltype(f)>(f), std::forward<decltype(v)>(v));
-            return make_race_promise(std::move(r));
-        });
-    }
-
-    template<typename ResolveF>
-    auto ThenTuple(ResolveF &&on_resolve)
-    {
-        return Then([f = std::forward<ResolveF>(on_resolve)](auto &&v) mutable {
-            auto r = eggs::invoke(std::forward<decltype(f)>(f), std::forward<decltype(v)>(v));
-            return make_tuple_promise(std::move(r));
-        });
-    }
-
-    //
-    // then
-    //
-
-    template<typename ResolveF, typename ResolveR = eggs::invoke_result_t<ResolveF, T>>
-    std::enable_if_t<!is_promise_v<ResolveR>, promise<ResolveR>> Then(ResolveF &&on_resolve)
-    {
-        promise<ResolveR> next;
-
-        state_->Attach(
-            next, std::forward<ResolveF>(on_resolve),
-            [](std::exception_ptr e) -> ResolveR { std::rethrow_exception(e); }, false);
-
-        return next;
-    }
-
-    template<typename ResolveF, typename RejectF, typename ResolveR = eggs::invoke_result_t<ResolveF, T>>
-    std::enable_if_t<!is_promise_v<ResolveR>, promise<ResolveR>> Then(ResolveF &&on_resolve, RejectF &&on_reject)
-    {
-        promise<ResolveR> next;
-
-        state_->Attach(next, std::forward<ResolveF>(on_resolve), std::forward<RejectF>(on_reject), true);
-
-        return next;
-    }
-
-    //
-    // except
-    //
-
-    template<typename RejectF>
-    promise<T> Except(RejectF &&on_reject)
-    {
-        return Then([](auto &&v) { return std::forward<decltype(v)>(v); }, std::forward<RejectF>(on_reject));
-    }
-
-    //
-    // finally
-    //
-
-    template<typename FinallyF>
-    promise<T> Finally(FinallyF &&on_finally)
-    {
-        return Then(
-            [f = on_finally](auto &&v) {
-                eggs::invoke(std::move(f));
-                return std::forward<decltype(v)>(v);
-            },
-            [f = on_finally](std::exception_ptr e) -> T {
-                eggs::invoke(std::move(f));
-                std::rethrow_exception(e);
-            });
-    }
-
-private:
-    class state;
-    std::shared_ptr<state> state_;
-
-private:
-    class state final : private detail::noncopyable {
-    public:
-        state() = default;
-
-        const T &Get()
-        {
-            sled::MutexLock lock(&mutex_);
-            // std::unique_lock lock(mutex_);
-            // cond_var_.wait(lock, [this]() { return status_ != status::pending; });
-            cond_var_.Wait(lock, [this]() { return status_ != status::pending; });
-            if (status_ == status::rejected) { std::rethrow_exception(exception_); }
-            assert(status_ == status::resolved);
-            return *storage_;
-        }
-
-        void Wait() const noexcept
-        {
-            sled::MutexLock lock(&mutex_);
-            // std::unique_lock lock(mutex_);
-            // cond_var_.wait(lock, [this]() { return status_ != status::pending; });
-            cond_var_.Wait(lock, [this]() { return status_ != status::pending; });
-        }
-
-        template<typename Rep, typename Period>
-        promise_wait_status WaitFor(const std::chrono::duration<Rep, Period> &timeout_duration) const
-        {
-            sled::MutexLock lock(&mutex_);
-            // std::unique_lock lock(mutex_);
-            // return cond_var_.wait_for(lock, timeout_duration, [this]() { return status_ != status::pending; })
-            return cond_var_.WaitFor(
-                       lock,
-                       sled::TimeDelta::Micros(std::chrono::duration_cast<std::chrono::microseconds>(timeout_duration)),
-                       [this]() { return status_ != status::pending; })
-                ? promise_wait_status::no_timeout
-                : promise_wait_status::timeout;
-        }
-
-        template<typename Clock, typename Duration>
-        promise_wait_status WaitUntil(const std::chrono::time_point<Clock, Duration> &timeout_time) const
-        {
-            sled::MutexLock lock(&mutex_);
-            // std::unique_lock lock(mutex_);
-            // return cond_var_.wait_until(lock, timeout_time, [this]() { return status_ != status::pending; })
-            auto now = std::chrono::system_clock::now();
-            auto duration = timeout_time - now;
-
-            return cond_var_.WaitFor(
-                       lock, sled::TimeDelta::Micros(std::chrono::duration_cast<std::chrono::duration_cast>(duration)),
-                       [this]() { return status_ != status::pending; })
-                ? promise_wait_status::no_timeout
-                : promise_wait_status::timeout;
-        }
-
-        template<typename U>
-        bool Resolve(U &&value)
-        {
-            sled::MutexLock lock(&mutex_);
-            // std::lock_guard guard(mutex_);
-            if (status_ != status::pending) { return false; }
-            storage_ = std::forward<U>(value);
-            status_ = status::resolved;
-            invoke_resolve_handlers_();
-            // cond_var_.notify_all();
-            cond_var_.NotifyAll();
-            return true;
-        }
-
-        bool Reject(std::exception_ptr e) noexcept
-        {
-            sled::MutexLock lock(&mutex_);
-            // std::lock_guard guard(mutex_);
-            if (status_ != status::pending) { return false; }
-            exception_ = e;
-            status_ = status::rejected;
-            invoke_reject_handlers_();
-            cond_var_.NotifyAll();
-            return true;
-        }
-
-    public:
-        template<typename U, typename ResolveF, typename RejectF>
-        std::enable_if_t<std::is_void<U>::value, void>
-        Attach(promise<U> &next, ResolveF &&on_resolve, RejectF &&on_reject, bool has_reject)
-        {
-            auto reject_h = [n = next, f = std::forward<RejectF>(on_reject), has_reject](std::exception_ptr e) mutable {
-                if (has_reject) {
-                    try {
-                        eggs::invoke(std::forward<decltype(f)>(f), e);
-                        n.Resolve();
-                    } catch (...) {
-                        n.Reject(std::current_exception());
-                    }
-                } else {
-                    n.Reject(e);
-                }
-            };
-
-            auto resolve_h = [n = next, f = std::forward<ResolveF>(on_resolve)](auto &&v) mutable {
-                try {
-                    eggs::invoke(std::forward<decltype(f)>(f), std::forward<decltype(v)>(v));
-                    n.Resolve();
-                } catch (...) {
-                    n.Reject(std::current_exception());
-                }
-            };
-
-            sled::MutexLock lock(&mutex_);
-            // std::lock_guard guard(mutex_);
-            add_handlers_(std::move(resolve_h), std::move(reject_h));
-        }
-
-        template<typename U, typename ResolveF, typename RejectF>
-        std::enable_if_t<!std::is_void<U>::value, void>
-        Attach(promise<U> &next, ResolveF &&on_resolve, RejectF &&on_reject, bool has_reject)
-        {
-            auto reject_h = [n = next, f = std::forward<RejectF>(on_reject), has_reject](std::exception_ptr e) mutable {
-                if (has_reject) {
-                    try {
-                        auto r = eggs::invoke(std::forward<decltype(f)>(f), e);
-                        n.Resolve(std::move(r));
-                    } catch (...) {
-                        n.Reject(std::current_exception());
-                    }
-                } else {
-                    n.Reject(e);
-                }
-            };
-
-            auto resolve_h = [n = next, f = std::forward<ResolveF>(on_resolve)](auto &&v) mutable {
-                try {
-                    auto r = eggs::invoke(std::forward<decltype(f)>(f), std::forward<decltype(v)>(v));
-                    n.Resolve(std::move(r));
-                } catch (...) {
-                    n.Reject(std::current_exception());
-                }
-            };
-
-            sled::MutexLock lock(&mutex_);
-            // std::lock_guard guard(mutex_);
-            add_handlers_(std::move(resolve_h), std::move(reject_h));
-        }
-
-    private:
-        template<typename ResolveF, typename RejectF>
-        void add_handlers_(ResolveF &&resolve, RejectF &&reject)
-        {
-            if (status_ == status::resolved) {
-                eggs::invoke(std::forward<ResolveF>(resolve), *storage_);
-            } else if (status_ == status::rejected) {
-                eggs::invoke(std::forward<RejectF>(reject), exception_);
-            } else {
-                handlers_.push_back({std::forward<ResolveF>(resolve), std::forward<RejectF>(reject)});
-            }
-        }
-
-        void invoke_resolve_handlers_() noexcept
-        {
-            for (const auto &h : handlers_) { h.resolve_(*storage_); }
-            handlers_.clear();
-        }
-
-        void invoke_reject_handlers_() noexcept
-        {
-            for (const auto &h : handlers_) { h.reject_(exception_); }
-            handlers_.clear();
-        }
-
-    private:
-        enum class status { pending, resolved, rejected };
-
-        status status_{status::pending};
-        std::exception_ptr exception_{nullptr};
-
-        mutable sled::Mutex mutex_;
-        mutable sled::ConditionVariable cond_var_;
-
-        // mutable std::mutex mutex_;
-        // mutable std::condition_variable cond_var_;
-
-        struct handler {
-            using resolve_t = std::function<void(const T &)>;
-            using reject_t = std::function<void(std::exception_ptr)>;
-
-            resolve_t resolve_;
-            reject_t reject_;
-        };
-
-        detail::storage<T> storage_;
-        std::vector<handler> handlers_;
-    };
-};
-
-template<typename T>
-using future = promise<T>;
-}// namespace promise_hpp
-
-// -----------------------------------------------------------------------------
-//
-// promise<void>
-//
-// -----------------------------------------------------------------------------
-
-namespace promise_hpp {
-template<>
-class promise<void> final {
-public:
-    using value_type = void;
-
-    promise() : state_(std::make_shared<state>()) {}
-
-    promise(promise &&) = default;
-    promise &operator=(promise &&) = default;
-
-    promise(const promise &) = default;
-    promise &operator=(const promise &) = default;
-
-    void swap(promise &other) noexcept { state_.swap(other.state_); }
-
-    std::size_t hash() const noexcept { return std::hash<state *>()(state_.get()); }
-
-    friend bool operator<(const promise &l, const promise &r) noexcept { return l.state_ < r.state_; }
-
-    friend bool operator==(const promise &l, const promise &r) noexcept { return l.state_ == r.state_; }
-
-    friend bool operator!=(const promise &l, const promise &r) noexcept { return l.state_ != r.state_; }
-
-    promise GetFuture() const { return promise(*this); }
-
-    //
-    // get
-    //
-
-    void Get() const { state_->get(); }
-
-    void GetOr() const
-    {
-        try {
-            return Get();
-        } catch (...) {
-            // nothing
-        }
-    }
-
-    //
-    // wait
-    //
-
-    void Wait() const noexcept { state_->wait(); }
-
-    inline promise_wait_status WaitFor(const sled::TimeDelta &timeout_duration) const
-    {
-        return state_->wait_for(timeout_duration);
-    }
-
-    template<typename Rep, typename Period>
-    promise_wait_status WaitFor(const std::chrono::duration<Rep, Period> &timeout_duration) const
-    {
-        return state_->wait_for(timeout_duration);
-    }
-
-    template<typename Clock, typename Duration>
-    promise_wait_status WaitUntil(const std::chrono::time_point<Clock, Duration> &timeout_time) const
-    {
-        return state_->wait_until(timeout_time);
-    }
-
-    //
-    // resolve/reject
-    //
-
-    bool Resolve() { return state_->Resolve(); }
-
-    bool Reject(std::exception_ptr e) noexcept { return state_->Reject(e); }
-
-    template<typename E>
-    bool Reject(E &&e)
-    {
-        return state_->Reject(std::make_exception_ptr(std::forward<E>(e)));
-    }
-
-    //
-    // then
-    //
-
-    template<typename ResolveF, typename ResolveR = eggs::invoke_result_t<ResolveF>>
-    std::enable_if_t<is_promise_v<ResolveR>, promise<typename ResolveR::value_type>> Then(ResolveF &&on_resolve)
-    {
-        promise<typename ResolveR::value_type> next;
-
-        Then([n = next, f = std::forward<ResolveF>(on_resolve)]() mutable {
-            auto np = eggs::invoke(std::forward<decltype(f)>(f));
-            std::move(np)
-                .then([n](auto &&...nvs) mutable { n.resolve(std::forward<decltype(nvs)>(nvs)...); })
-                .except([n](std::exception_ptr e) mutable { n.reject(e); });
-        }).except([n = next](std::exception_ptr e) mutable { n.reject(e); });
-
-        return next;
-    }
-
-    template<typename ResolveF>
-    auto ThenAll(ResolveF &&on_resolve)
-    {
-        return Then([f = std::forward<ResolveF>(on_resolve)]() mutable {
-            auto r = eggs::invoke(std::forward<decltype(f)>(f));
-            return make_all_promise(std::move(r));
-        });
-    }
-
-    template<typename ResolveF>
-    auto ThenAny(ResolveF &&on_resolve)
-    {
-        return Then([f = std::forward<ResolveF>(on_resolve)]() mutable {
-            auto r = eggs::invoke(std::forward<decltype(f)>(f));
-            return make_any_promise(std::move(r));
-        });
-    }
-
-    template<typename ResolveF>
-    auto ThenRace(ResolveF &&on_resolve)
-    {
-        return Then([f = std::forward<ResolveF>(on_resolve)]() mutable {
-            auto r = eggs::invoke(std::forward<decltype(f)>(f));
-            return make_race_promise(std::move(r));
-        });
-    }
-
-    template<typename ResolveF>
-    auto ThenTuple(ResolveF &&on_resolve)
-    {
-        return Then([f = std::forward<ResolveF>(on_resolve)]() mutable {
-            auto r = eggs::invoke(std::forward<decltype(f)>(f));
-            return make_tuple_promise(std::move(r));
-        });
-    }
-
-    //
-    // then
-    //
-
-    template<typename ResolveF, typename ResolveR = eggs::invoke_result_t<ResolveF>>
-    std::enable_if_t<!is_promise_v<ResolveR>, promise<ResolveR>> Then(ResolveF &&on_resolve)
-    {
-        promise<ResolveR> next;
-
-        state_->attach(
-            next, std::forward<ResolveF>(on_resolve),
-            [](std::exception_ptr e) -> ResolveR { std::rethrow_exception(e); }, false);
-
-        return next;
-    }
-
-    template<typename ResolveF, typename RejectF, typename ResolveR = eggs::invoke_result_t<ResolveF>>
-    std::enable_if_t<!is_promise_v<ResolveR>, promise<ResolveR>> Then(ResolveF &&on_resolve, RejectF &&on_reject)
-    {
-        promise<ResolveR> next;
-
-        state_->attach(next, std::forward<ResolveF>(on_resolve), std::forward<RejectF>(on_reject), true);
-
-        return next;
-    }
-
-    //
-    // except
-    //
-
-    template<typename RejectF>
-    promise<void> Except(RejectF &&on_reject)
-    {
-        return Then([]() {}, std::forward<RejectF>(on_reject));
-    }
-
-    //
-    // finally
-    //
-
-    template<typename FinallyF>
-    promise<void> Finally(FinallyF &&on_finally)
-    {
-        return Then([f = on_finally]() { eggs::invoke(std::move(f)); },
-                    [f = on_finally](std::exception_ptr e) {
-                        eggs::invoke(std::move(f));
-                        std::rethrow_exception(e);
-                    });
-    }
-
-private:
-    class state;
-    std::shared_ptr<state> state_;
-
-private:
-    class state final : private detail::noncopyable {
-    public:
-        state() = default;
-
-        void get()
-        {
-            sled::MutexLock lock(&mutex_);
-            // std::unique_lock lock(mutex_);
-            // cond_var_.wait(lock, [this]() { return status_ != status::pending; });
-            cond_var_.Wait(lock, [this]() { return status_ != status::pending; });
-            if (status_ == status::rejected) { std::rethrow_exception(exception_); }
-            assert(status_ == status::resolved);
-        }
-
-        void wait() const noexcept
-        {
-            sled::MutexLock lock(&mutex_);
-            // std::unique_lock lock(mutex_);
-            // cond_var_.wait(lock, [this]() { return status_ != status::pending; });
-            cond_var_.Wait(lock, [this]() { return status_ != status::pending; });
-        }
-
-        promise_wait_status wait_for(const sled::TimeDelta &timeout_duration) const
-        {
-            sled::MutexLock lock(&mutex_);
-            // std::unique_lock lock(mutex_);
-            // return cond_var_.wait_for(lock, timeout_duration, [this]() { return status_ != status::pending; })
-            return cond_var_.WaitFor(lock, timeout_duration, [this]() { return status_ != status::pending; })
-                ? promise_wait_status::no_timeout
-                : promise_wait_status::timeout;
-        }
-
-        template<typename Rep, typename Period>
-        promise_wait_status wait_for(const std::chrono::duration<Rep, Period> &timeout_duration) const
-        {
-            sled::MutexLock lock(&mutex_);
-            // std::unique_lock lock(mutex_);
-            // return cond_var_.wait_for(lock, timeout_duration, [this]() { return status_ != status::pending; })
-            return cond_var_.WaitFor(lock, timeout_duration, [this]() { return status_ != status::pending; })
-                ? promise_wait_status::no_timeout
-                : promise_wait_status::timeout;
-        }
-
-        template<typename Clock, typename Duration>
-        promise_wait_status wait_until(const std::chrono::time_point<Clock, Duration> &timeout_time) const
-        {
-            sled::MutexLock lock(&mutex_);
-            // std::unique_lock lock(mutex_);
-            // return cond_var_.wait_until(lock, timeout_time, [this]() { return status_ != status::pending; })
-            auto duration = timeout_time - std::chrono::system_clock::now();
-            return cond_var_.WaitFor(lock, duration, [this]() { return status_ != status::pending; })
-                ? promise_wait_status::no_timeout
-                : promise_wait_status::timeout;
-        }
-
-        bool Resolve()
-        {
-            sled::MutexLock lock(&mutex_);
-            // std::unique_lock lock(mutex_);
-            // std::lock_guard guard(mutex_);
-            if (status_ != status::pending) { return false; }
-            status_ = status::resolved;
-            invoke_resolve_handlers_();
-            cond_var_.NotifyAll();
-            return true;
-        }
-
-        bool Reject(std::exception_ptr e) noexcept
-        {
-            sled::MutexLock lock(&mutex_);
-            // std::lock_guard guard(mutex_);
-            if (status_ != status::pending) { return false; }
-            exception_ = e;
-            status_ = status::rejected;
-            invoke_reject_handlers_();
-            cond_var_.NotifyAll();
-            return true;
-        }
-
-    public:
-        template<typename U, typename ResolveF, typename RejectF>
-        std::enable_if_t<std::is_void<U>::value, void>
-        attach(promise<U> &next, ResolveF &&on_resolve, RejectF &&on_reject, bool has_reject)
-        {
-            auto reject_h = [n = next, f = std::forward<RejectF>(on_reject), has_reject](std::exception_ptr e) mutable {
-                if (has_reject) {
-                    try {
-                        eggs::invoke(std::forward<decltype(f)>(f), e);
-                        n.Resolve();
-                    } catch (...) {
-                        n.Reject(std::current_exception());
-                    }
-                } else {
-                    n.Reject(e);
-                }
-            };
-
-            auto resolve_h = [n = next, f = std::forward<ResolveF>(on_resolve)]() mutable {
-                try {
-                    eggs::invoke(std::forward<decltype(f)>(f));
-                    n.Resolve();
-                } catch (...) {
-                    n.Reject(std::current_exception());
-                }
-            };
-
-            sled::MutexLock lock(&mutex_);
-            // std::lock_guard guard(mutex_);
-            add_handlers_(std::move(resolve_h), std::move(reject_h));
-        }
-
-        template<typename U, typename ResolveF, typename RejectF>
-        std::enable_if_t<!std::is_void<U>::value, void>
-        attach(promise<U> &next, ResolveF &&on_resolve, RejectF &&on_reject, bool has_reject)
-        {
-            auto reject_h = [n = next, f = std::forward<RejectF>(on_reject), has_reject](std::exception_ptr e) mutable {
-                if (has_reject) {
-                    try {
-                        auto r = eggs::invoke(std::forward<decltype(f)>(f), e);
-                        n.Resolve(std::move(r));
-                    } catch (...) {
-                        n.Reject(std::current_exception());
-                    }
-                } else {
-                    n.Reject(e);
-                }
-            };
-
-            auto resolve_h = [n = next, f = std::forward<ResolveF>(on_resolve)]() mutable {
-                try {
-                    auto r = eggs::invoke(std::forward<decltype(f)>(f));
-                    n.Resolve(std::move(r));
-                } catch (...) {
-                    n.Reject(std::current_exception());
-                }
-            };
-
-            sled::MutexLock lock(&mutex_);
-            // std::lock_guard guard(mutex_);
-            add_handlers_(std::move(resolve_h), std::move(reject_h));
-        }
-
-    private:
-        template<typename ResolveF, typename RejectF>
-        void add_handlers_(ResolveF &&resolve, RejectF &&reject)
-        {
-            if (status_ == status::resolved) {
-                eggs::invoke(std::forward<ResolveF>(resolve));
-            } else if (status_ == status::rejected) {
-                eggs::invoke(std::forward<RejectF>(reject), exception_);
-            } else {
-                handlers_.push_back({std::forward<ResolveF>(resolve), std::forward<RejectF>(reject)});
-            }
-        }
-
-        void invoke_resolve_handlers_() noexcept
-        {
-            for (const auto &h : handlers_) { h.resolve_(); }
-            handlers_.clear();
-        }
-
-        void invoke_reject_handlers_() noexcept
-        {
-            for (const auto &h : handlers_) { h.reject_(exception_); }
-            handlers_.clear();
-        }
-
-    private:
-        enum class status { pending, resolved, rejected };
-
-        status status_{status::pending};
-        std::exception_ptr exception_{nullptr};
-
-        mutable sled::Mutex mutex_;
-        mutable sled::ConditionVariable cond_var_;
-
-        // mutable std::mutex mutex_;
-        // mutable std::condition_variable cond_var_;
-
-        struct handler {
-            using resolve_t = std::function<void()>;
-            using reject_t = std::function<void(std::exception_ptr)>;
-
-            resolve_t resolve_;
-            reject_t reject_;
-        };
-
-        std::vector<handler> handlers_;
-    };
-};
-}// namespace promise_hpp
-
-namespace promise_hpp {
-//
-// swap
-//
-
-template<typename T>
-void
-swap(promise<T> &l, promise<T> &r) noexcept
-{
-    l.swap(r);
-}
-
-//
-// make_promise
-//
-
-template<typename R>
-promise<R>
-make_promise()
-{
-    return promise<R>();
-}
-
-template<typename R, typename F>
-promise<R>
-make_promise(F &&f)
-{
-    promise<R> result;
-
-    auto resolver = [result](auto &&v) mutable { return result.Resolve(std::forward<decltype(v)>(v)); };
-
-    auto rejector = [result](auto &&e) mutable { return result.Reject(std::forward<decltype(e)>(e)); };
-
-    try {
-        eggs::invoke(std::forward<F>(f), std::move(resolver), std::move(rejector));
-    } catch (...) {
-        result.Reject(std::current_exception());
-    }
-
-    return result;
-}
-
-//
-// make_resolved_promise
-//
-
-inline promise<void>
-make_resolved_promise()
-{
-    promise<void> result;
-    result.Resolve();
-    return result;
-}
-
-template<typename R>
-promise<std::decay_t<R>>
-make_resolved_promise(R &&v)
-{
-    promise<std::decay_t<R>> result;
-    result.Resolve(std::forward<R>(v));
-    return result;
-}
-
-//
-// make_rejected_promise
-//
-
-template<typename E>
-promise<void>
-make_rejected_promise(E &&e)
-{
-    promise<void> result;
-    result.Reject(std::forward<E>(e));
-    return result;
-}
-
-template<typename R, typename E>
-promise<R>
-make_rejected_promise(E &&e)
-{
-    promise<R> result;
-    result.Reject(std::forward<E>(e));
-    return result;
-}
-
-//
-// make_all_promise
-//
-
-template<typename Iter,
-         typename SubPromise = typename std::iterator_traits<Iter>::value_type,
-         typename SubPromiseResult = typename SubPromise::value_type,
-         typename ResultPromiseValueType = std::vector<SubPromiseResult>>
-promise<ResultPromiseValueType>
-make_all_promise(Iter begin, Iter end)
-{
-    if (begin == end) { return make_resolved_promise(ResultPromiseValueType()); }
-
-    struct context_t {
-        std::atomic_size_t success_counter{0u};
-        std::vector<detail::storage<SubPromiseResult>> results;
-
-        context_t(std::size_t count) : success_counter(count), results(count) {}
-    };
-
-    return make_promise<ResultPromiseValueType>([begin, end](auto &&resolver, auto &&rejector) {
-        std::size_t result_index = 0;
-        auto context = std::make_shared<context_t>(std::distance(begin, end));
-        for (Iter iter = begin; iter != end; ++iter, ++result_index) {
-            (*iter)
-                .then([context, resolver, result_index](auto &&v) mutable {
-                    context->results[result_index] = std::forward<decltype(v)>(v);
-                    if (!--context->success_counter) {
-                        std::vector<SubPromiseResult> results;
-                        results.reserve(context->results.size());
-                        for (auto &&r : context->results) { results.push_back(std::move(*r)); }
-                        resolver(std::move(results));
-                    }
-                })
-                .except([rejector](std::exception_ptr e) mutable { rejector(e); });
-        }
-    });
-}
-
-template<typename Container>
-auto
-make_all_promise(Container &&container)
-{
-    return make_all_promise(std::begin(container), std::end(container));
-}
-
-//
-// make_any_promise
-//
-
-template<typename Iter,
-         typename SubPromise = typename std::iterator_traits<Iter>::value_type,
-         typename SubPromiseResult = typename SubPromise::value_type,
-         typename ResultPromiseValueType = SubPromiseResult>
-promise<ResultPromiseValueType>
-make_any_promise(Iter begin, Iter end)
-{
-    if (begin == end) { return make_rejected_promise<ResultPromiseValueType>(aggregate_exception()); }
-
-    struct context_t {
-        std::atomic_size_t failure_counter{0u};
-        std::vector<std::exception_ptr> exceptions;
-
-        context_t(std::size_t count) : failure_counter(count), exceptions(count) {}
-    };
-
-    return make_promise<ResultPromiseValueType>([begin, end](auto &&resolver, auto &&rejector) {
-        std::size_t exception_index = 0;
-        auto context = std::make_shared<context_t>(std::distance(begin, end));
-        for (Iter iter = begin; iter != end; ++iter, ++exception_index) {
-            (*iter)
-                .then([resolver](auto &&v) mutable { resolver(std::forward<decltype(v)>(v)); })
-                .except([context, rejector, exception_index](std::exception_ptr e) mutable {
-                    context->exceptions[exception_index] = e;
-                    if (!--context->failure_counter) { rejector(aggregate_exception(std::move(context->exceptions))); }
-                });
-        }
-    });
-}
-
-template<typename Container>
-auto
-make_any_promise(Container &&container)
-{
-    return make_any_promise(std::begin(container), std::end(container));
-}
-
-//
-// make_race_promise
-//
-
-template<typename Iter,
-         typename SubPromise = typename std::iterator_traits<Iter>::value_type,
-         typename SubPromiseResult = typename SubPromise::value_type,
-         typename ResultPromiseValueType = SubPromiseResult>
-promise<ResultPromiseValueType>
-make_race_promise(Iter begin, Iter end)
-{
-    return make_promise<ResultPromiseValueType>([begin, end](auto &&resolver, auto &&rejector) {
-        for (Iter iter = begin; iter != end; ++iter) { (*iter).then(resolver).except(rejector); }
-    });
-}
-
-template<typename Container>
-auto
-make_race_promise(Container &&container)
-{
-    return make_race_promise(std::begin(container), std::end(container));
-}
-
-//
-// make_tuple_promise
-//
-
-namespace impl {
-template<typename Tuple>
-struct tuple_promise_result_impl {};
-
-template<typename... Args>
-struct tuple_promise_result_impl<std::tuple<promise<Args>...>> {
-    using type = std::tuple<Args...>;
-};
-
-template<typename Tuple>
-struct tuple_promise_result {
-    using type = typename tuple_promise_result_impl<std::remove_cv_t<Tuple>>::type;
-};
-
-template<typename Tuple>
-using tuple_promise_result_t = typename tuple_promise_result<Tuple>::type;
-
-template<typename... ResultTypes>
-class tuple_promise_context_t final : private detail::noncopyable {
-public:
-    template<std::size_t N, typename T>
-    bool apply_result(T &&value)
-    {
-        std::get<N>(results_) = std::forward<T>(value);
-        return ++counter_ == sizeof...(ResultTypes);
-    }
-
-    std::tuple<ResultTypes...> get_results()
-    {
-        return get_results_impl(std::make_index_sequence<sizeof...(ResultTypes)>());
-    }
-
-private:
-    template<std::size_t... Is>
-    std::tuple<ResultTypes...> get_results_impl(std::index_sequence<Is...>)
-    {
-        return {std::move(*std::get<Is>(results_))...};
-    }
-
-private:
-    std::atomic_size_t counter_{0};
-    std::tuple<detail::storage<ResultTypes>...> results_;
-};
-
-template<typename... ResultTypes>
-using tuple_promise_context_ptr = std::shared_ptr<tuple_promise_context_t<ResultTypes...>>;
-
-template<std::size_t I, typename Tuple, typename Resolver, typename Rejector, typename... ResultTypes>
-promise<void>
-make_tuple_sub_promise_impl(Tuple &&tuple,
-                            Resolver &&resolver,
-                            Rejector &&rejector,
-                            const tuple_promise_context_ptr<ResultTypes...> &context)
-{
-    return std::get<I>(tuple)
-        .then([context, resolver](auto &&v) mutable {
-            if (context->template apply_result<I>(std::forward<decltype(v)>(v))) { resolver(context->get_results()); }
-        })
-        .except(rejector);
-}
-
-template<typename Tuple, std::size_t... Is, typename ResultTuple = tuple_promise_result_t<std::decay_t<Tuple>>>
-std::enable_if_t<sizeof...(Is) == 0, promise<ResultTuple>>
-make_tuple_promise_impl(Tuple &&, std::index_sequence<Is...>)
-{
-    return make_resolved_promise(ResultTuple());
-}
-
-template<typename Tuple, std::size_t... Is, typename ResultTuple = tuple_promise_result_t<std::decay_t<Tuple>>>
-std::enable_if_t<sizeof...(Is) != 0, promise<ResultTuple>>
-make_tuple_promise_impl(Tuple &&tuple, std::index_sequence<Is...>)
-{
-    auto result = promise<ResultTuple>();
-
-    auto resolver = [result](auto &&v) mutable { return result.resolve(std::forward<decltype(v)>(v)); };
-
-    auto rejector = [result](auto &&e) mutable { return result.reject(std::forward<decltype(e)>(e)); };
-
-    try {
-        auto context = std::make_shared<tuple_promise_context_t<std::tuple_element_t<Is, ResultTuple>...>>();
-        auto promises = std::make_tuple(make_tuple_sub_promise_impl<Is>(tuple, resolver, rejector, context)...);
-        (void) promises;
-    } catch (...) {
-        result.reject(std::current_exception());
-    }
-
-    return result;
-}
-}// namespace impl
-
-template<typename Tuple, typename ResultTuple = impl::tuple_promise_result_t<std::decay_t<Tuple>>>
-promise<ResultTuple>
-make_tuple_promise(Tuple &&tuple)
-{
-    return impl::make_tuple_promise_impl(std::forward<Tuple>(tuple),
-                                         std::make_index_sequence<std::tuple_size<ResultTuple>::value>());
-}
-}// namespace promise_hpp
-
-namespace std {
-template<typename T>
-struct hash<promise_hpp::promise<T>> final {
-    std::size_t operator()(const promise_hpp::promise<T> &p) const noexcept { return p.hash(); }
-};
-}// namespace std
-
-namespace sled {
-
-template<typename T>
-struct IsPromise : promise_hpp::is_promise<T> {};
-
-template<typename TRet, typename TPromise>
-struct IsPromiseRet : promise_hpp::is_promise_r<TRet, TPromise> {};
-
-template<typename T>
-using Promise = promise_hpp::promise<T>;
-
-template<typename T>
-using Future = promise_hpp::future<T>;
-
-template<typename T>
-inline auto
-MakePromise() -> Promise<T>
-{
-    return promise_hpp::make_promise<T>();
-}
-
-template<typename T, typename F>
-inline auto
-MakePromise(F &&f)
-{
-    return promise_hpp::make_promise<T, F>(std::forward<F>(f));
-}
-
-inline auto
-MakeResolvedPromise() -> Promise<void>
-{
-    Promise<void> result;
-    result.Resolve();
-    return result;
-}
-
-template<typename T>
-inline auto
-MakeResolvedPromise()
-{
-    return promise_hpp::make_resolved_promise<T>();
-}
-
-template<typename E>
-inline Promise<void>
-make_rejected_promise(E &&e)
-{
-    Promise<void> result;
-    result.Reject(std::forward<E>(e));
-    return result;
-}
-
-template<typename T>
-inline auto
-MakeRejectedPromise(std::exception_ptr e)
-{
-    return promise_hpp::make_rejected_promise<T>(e);
-}
-
-template<typename Iter>
-inline auto
-MakeAllPromise(Iter begin, Iter end)
-{
-    return promise_hpp::make_all_promise(begin, end);
-}
-
-template<typename Container>
-inline auto
-MakeAllPromise(Container &&container)
-{
-    return promise_hpp::make_all_promise(std::begin(container), std::end(container));
-}
-
-template<typename Iter>
-inline auto
-MakeAnyPromise(Iter begin, Iter end)
-{
-    return promise_hpp::make_any_promise(begin, end);
-}
-
-template<typename Container>
-inline auto
-MakeAnyPromise(Container &&container)
-{
-    return promise_hpp::make_any_promise(std::begin(container), std::end(container));
-}
-
-template<typename Iter>
-inline auto
-MakeRacePromise(Iter begin, Iter end)
-{
-    return promise_hpp::make_any_promise(begin, end);
-}
-
-template<typename Container>
-inline auto
-MakeRacePromise(Container &&container)
-{
-    return promise_hpp::make_any_promise(std::begin(container), std::end(container));
-}
-
-}// namespace sled
-
-#endif// SLED_FUTURES_PROMISE_H
diff --git a/src/sled/futures/promise_test.cc b/src/sled/futures/promise_test.cc
deleted file mode 100644
index d4d675b..0000000
--- a/src/sled/futures/promise_test.cc
+++ /dev/null
@@ -1,57 +0,0 @@
-#include <gtest/gtest.h>
-#include <sled/futures/promise.h>
-
-TEST(Promise, Basic)
-{
-    auto p = sled::Promise<int>();
-    auto v = p.Then([](int v) {
-                  EXPECT_EQ(v, 1);
-                  return v + 10;
-              })
-                 .Tap([](int v) {
-                     EXPECT_EQ(v, 11);
-                     // no effect
-                     return v + 1;
-                 })
-                 .Then([](int v) {
-                     EXPECT_EQ(v, 11);
-                     return v + 10;
-                 });
-    p.Resolve(1);
-}
-
-TEST(Future, Basic)
-{
-    auto p      = sled::Promise<int>();
-    auto future = p.GetFuture()
-                      .Then([](int v) {
-                          EXPECT_EQ(v, 1);
-                          return v + 10;
-                      })
-                      .Then([](int v) {
-                          EXPECT_EQ(v, 11);
-                          return v + 10;
-                      });
-    p.Resolve(1);
-    EXPECT_EQ(future.Get(), 21);
-}
-
-TEST(Future, Except)
-{
-    auto p = sled::Promise<int>();
-    p.Resolve(1);
-    p.GetFuture()
-        .Then([](int) {
-            return 1;
-            // throw std::runtime_error("test");
-        })
-        .Except([](std::exception_ptr e) {
-            try {
-                std::rethrow_exception(e);
-            } catch (const std::exception &e) {
-                EXPECT_STREQ(e.what(), "test");
-            }
-            return false;
-        })
-        .Get();
-}