future.h

#pragma once
#include "common.h"
#include "function.h"
#include "exceptions.h"
 
#include "prepared_coro.h"
#include "allocator.h"
#include "construct.h"
 
#include <atomic>
#include <memory>
#include <optional>
#include <utility>
#include <bit>
 
namespace coro {
 
 
template<typename T>
class future;
 
template<typename T, bool atomic = false>
class promise;
 
template<typename T>
class deferred_future;
 
namespace _details {
template<typename T> class coro_promise_base;
};
 
template<typename T, typename ... Args>
concept avoid_same_kind = sizeof...(Args) != 1 || !std::is_same_v<T, std::decay_t<Args>...>;
 
template<typename Alloc>
concept is_allocator = requires(Alloc alloc, std::size_t n) {
    {alloc.allocate(n)} -> std::same_as<typename Alloc::value_type *>;
};
 
template<typename T, typename Ret, typename ... Args>
concept invocable_r_exact = std::is_same_v<std::invoke_result_t<T, Args...>, Ret>;
 
template<typename T, typename ... U>
concept future_constructible = ((sizeof...(U) == 1 && (invocable_r_exact<U, T> && ...)) || std::is_constructible_v<T, U...>);
 
template<typename T>
using atomic_promise = promise<T, true>;
 
 
template<typename T, bool atomic>
class promise {
public:
 
    using FutureType = future<T>;
 
 
 
    class notify {
    public:
        using FutureType = future<T>;
 
        notify() = default;
 
        void cancel() {_ptr->clearStorage();}
        void deliver() {_ptr.reset();}
 
 
        template<std::invocable<function<prepared_coro()>  > Fn>
        void deliver(Fn &&fn) {
            auto ptr = _ptr.release();
            if (ptr) ptr->set_resolved(std::forward<Fn>(fn));
        }
 
 
 
        std::coroutine_handle<> symmetric_transfer() {
            auto ptr = _ptr.release();
            if (ptr) {
                prepared_coro retval;
                ptr->set_resolved([&](auto &&awt){
                    retval = awt();
                });
                return retval.symmetric_transfer();
            } else {
                return std::noop_coroutine();
            }
 
        }
        explicit operator bool() const {return static_cast<bool>(_ptr);}
 
        void operator()() {
            _ptr.reset();
        }
 
        notify operator+(notify &other) {
            if (_ptr == nullptr) return std::move(other);
            _ptr->attach(other._ptr.release());
            return std::move(*this);
        }
 
        notify &operator+=(notify &other) {
            if (_ptr == nullptr) {
                _ptr = std::move(other._ptr);
            } else {
                _ptr->attach(other._ptr.release());
            }
            return *this;
        }
 
        notify &operator+=(notify &&other) {
            return operator+=(other);
        }
 
    protected:
 
        notify(FutureType *fut):_ptr(fut) {}
 
        struct NotifyAction {
            void operator()(FutureType *fut) {fut->set_resolved([](auto &c){c();});}
        };
 
        std::unique_ptr<FutureType, NotifyAction> _ptr;
 
        friend class promise<T>;
    };
 
 
 
 
    promise() = default;
 
 
    explicit promise(FutureType *ptr):_ptr(ptr) {}
 
    promise(promise &&other):_ptr(other.claim()) {}
 
    template<bool x>
    promise(promise<T, x> &&other): _ptr(other.claim()) {}
 
    promise &operator=(promise &&other) {
        if (this != &other) {
            cancel();
            _ptr.store(other.claim(), std::memory_order_relaxed);
        }
        return *this;
    }
 
    ~promise() {
        cancel();
    }
 
 
    notify cancel() {
        return claim();
    }
 
 
    template<typename ... Args>
    notify operator()(Args && ... args) {
        static_assert((std::is_void_v<T> && sizeof...(Args) == 0)
                        || future_constructible<T, Args ...>, "Value is not constructible from arguments");
        auto fut = claim();
        if (fut) fut->set_value(std::forward<Args>(args)...);
        return fut;
    }
 
 
    notify reject(std::exception_ptr e) {
        auto fut = claim();
        if (fut) fut->set_exception(std::move(e));
        return fut;
    }
 
 
    notify reject() {
        auto e = std::current_exception();
        return e?reject(std::move(e)):cancel();
    }
 
    template<typename E>
    notify reject(E && exception) {
        return reject(std::make_exception_ptr<std::decay_t<E> >(std::forward<E>(exception)));
    }
 
 
    FutureType *release() {
        return claim();
    }
 
 
    const FutureType *get_future() const {
        return _ptr.load(std::memory_order_relaxed);
    }
 
 
 
    template<bool f>
    promise &operator+=(promise<T, f> &other) {
        promise z =  other + (*this);
        _ptr = z.claim();
        return *this;
    }
 
    template<bool f>
    promise &operator+=(promise<T, f> &&other) {
        return this->operator+=(other);
    }
 
 
    template<bool f>
    promise operator+(promise<T, f> &other) {
        static_assert(std::is_void_v<T> || std::is_copy_constructible_v<T>, "Requires T copy constructible");
        auto a = claim();
        auto b = other.claim();
        if (!a) return promise(b);
        a->attach(b);
        return promise(a);
    }
 
    operator bool () const {
        return _ptr.load(std::memory_order_relaxed) != nullptr;
    }
 
protected:
 
    struct non_atomic {
        FutureType *_ptr = {};
        non_atomic() = default;
        non_atomic(FutureType *ptr):_ptr(ptr) {}
        FutureType *exchange(FutureType *x, std::memory_order) {
            return std::exchange(_ptr, x);
        }
        void store(FutureType *x, std::memory_order) {
            _ptr = x;
        }
        FutureType *load(std::memory_order) const {
            return _ptr;
        }
        bool compare_exchange_strong(FutureType *& old, FutureType *nw) {
            if (_ptr == old) {
                _ptr = nw;
                return true;
            } else {
                old = _ptr;
                return false;
            }
        }
    };
 
    using Holder = std::conditional_t<atomic, std::atomic<FutureType *>, non_atomic>;
 
    Holder _ptr = {};
 
    FutureType *claim() {return _ptr.exchange(nullptr, std::memory_order_relaxed);}
};
 
struct deferred_tag {};
 
inline constexpr deferred_tag deferred=  {};
 
namespace _details {
 
    template<typename T>
    class wait_awaiter {
    public:
        wait_awaiter(T *fut):self(fut) {}
        wait_awaiter(const wait_awaiter &other) = delete;
        wait_awaiter &operator=(const wait_awaiter &other) = delete;
        ~wait_awaiter() {wait_now();}
        bool await_ready() const noexcept {return self->await_ready();}
        auto await_suspend(std::coroutine_handle<> h) noexcept {return self->await_suspend(h);}
        void await_resume() const noexcept {}
    protected:
        T *self;
        void wait_now() {
            self->wait_internal();
        }
 
    };
 
    template<typename T, bool flag>
    class [[nodiscard]] has_value_awaiter: public wait_awaiter<T> {
    public:
        using wait_awaiter<T>::wait_awaiter;
        bool await_resume() const noexcept {
            return this->self->has_value() == flag;
        }
        has_value_awaiter<T, !flag> operator !() const {return this->self;}
        operator bool() {
            this->wait_now();
            return await_resume();
        }
    };
 
}
 
 
template<typename T>
class [[nodiscard]] future {
public:
 
    /*
     *   +-------------------+
     *   |   chain           |  8
     *   +-------------------+
     *   |   atomic(_state)  |  1
     *   +-------------------+
     *   |   enum(_result)   |  1
     *   +-------------------+
     *   |   await_cleanup   |  1
     *   +-------------------+ (padding 5)
     *   +-------------------+
     *   |                   |
     *   |  * awaiter        |
     *   |  * deferred       |  32
     *   |                   |
     *   +-------------------+
     *   |                   |
     *   |  * exception      |
     *   |  * value          |  8+
     *   |                   |
     *   +-------------------+
     *
     *                          56+
     */
 
 
    using value_type = T;
    using promise_t = promise<T>;
    using value_store_type = std::conditional_t<std::is_reference_v<T>,
                                                        std::add_pointer_t<std::remove_reference_t<T> >,
                                                        std::conditional_t<std::is_void_v<T>, bool, T> >;
 
    using cast_ret_value = std::conditional_t<std::is_void_v<T>, bool, std::add_rvalue_reference_t<T> >;
 
    using ret_value = std::conditional_t<std::is_void_v<T>, void, std::add_rvalue_reference_t<T> >;
    using awaiter_type = function<prepared_coro()>;
    using deferred_eval_fn_type = function<prepared_coro(promise_t)>;
    using wait_awaiter = _details::wait_awaiter<future>;
    using canceled_awaiter = _details::has_value_awaiter<future,false>;
 
    future() {/*can't be default*/}
 
    future(const future &) = delete;        //<can't copy nor move
    future &operator=(const future &) = delete; //<can't copy nor move
 
    template<typename ... Args>
    requires (std::constructible_from<value_store_type, Args ...> && avoid_same_kind<future, Args...>)
    future(Args && ... args):_result(Result::value), _value(std::forward<Args>(args)...) {}
 
 
 
    template<typename ... Args>
    future(std::in_place_t, Args &&... args): _result(Result::value), _value(std::forward<Args>(args)...) {}
 
    future(std::exception_ptr e):_result(Result::exception), _exception(std::move(e)) {}
 
 
    template<std::invocable<promise_t> Fn>
    future(Fn &&fn):_state(State::pending) {
        std::forward<Fn>(fn)(promise_t(this));
    }
 
 
    template<std::invocable<promise_t> Fn>
    future(deferred_tag, Fn &&fn) {
        setDeferredEvaluation(std::forward<Fn>(fn));
    }
 
    template<invocable_r_exact<future<T> > Fn>
    future(Fn &&fn) {
        new(this) future(std::forward<Fn>(fn)());
    }
 
 
    ~future() {
        checkInProgress();
        if (_state.load(std::memory_order_relaxed) == State::deferred) {
            std::destroy_at(&_deferred);
        }
        clearStorage();
    }
 
 
    template<invocable_r_exact<future> Fn>
    future &operator << (Fn &&fn) {
        std::destroy_at(this);
        try {
            std::construct_at(this, std::forward<Fn>(fn));
        } catch (...) {
            std::construct_at(this);
        }
        return *this;
    }
 
 
    promise_t get_promise() {
        auto old = State::resolved;
        if (!_state.compare_exchange_strong(old, State::pending)) {
            if (old == State::deferred) {
                std::destroy_at(&_deferred);
                _state.store(State::pending);
            } else {
                throw still_pending_exception();
            }
        }
        clearStorage();
        _chain = nullptr;
        return promise_t{this};
    }
 
 
    prepared_coro start() {
        prepared_coro out;
        if (is_deferred()) {
            startDeferredEvaluation([&](auto &&h){out = std::move(h);});
        }
        return out;
    }
 
 
    template<std::invocable<> Fn>
    [[nodiscard]] bool set_callback(Fn &&fn) {
        return RegAwtRes::constructed_ready == register_awaiter(std::forward<Fn>(fn), [](auto &&){});
    }
 
 
    bool unset_callback() {
        return RegAwtRes::constructed_ready == register_awaiter([]{return prepared_coro{};}, [](auto &&){});
    }
 
 
 
    template<std::invocable<> Fn>
    bool then(Fn &&fn) {
        auto res = register_awaiter(std::forward<Fn>(fn), [](auto &&){});
        switch (res) {
            case RegAwtRes::resolved: {
                 fn();
            } return false;
            case RegAwtRes::constructed_resolved: {
                _awaiter();
            } return false;
            default:
                return true;
        }
    }
 
 
    template<std::invocable<> Fn>
    bool operator>>(Fn &&fn) {
        return then(std::forward<Fn>(fn));
    }
 
 
 
 
    wait_awaiter wait() noexcept {return this;}
 
 
    ret_value get() {
        wait();
        return await_resume();
    }
 
    operator cast_ret_value() {
        wait();
        return getInternal();
    }
 
 
    bool is_pending() const {
        return _state.load(std::memory_order_relaxed) != State::resolved;
    }
 
 
    bool is_in_progress() const {
        auto st = _state.load(std::memory_order_relaxed);
        return st != State::resolved && st != State::deferred;
    }
 
 
    bool is_deferred() const {
        return _state.load(std::memory_order_relaxed) == State::deferred;
    }
 
 
    bool is_awaited() const {
        return _state.load(std::memory_order_relaxed) == State::awaited;
    }
 
    bool await_ready() const noexcept {
        return _state.load(std::memory_order_relaxed) == State::resolved;
    }
 
 
    std::coroutine_handle<> await_suspend(std::coroutine_handle<> h) noexcept {
        prepared_coro retval = {};
        auto cb = [h]{return h;};
        auto resume_fn = [&retval](prepared_coro h){retval = std::move(h);};
        if (RegAwtRes::constructed_ready == register_awaiter(cb, resume_fn)) {
            return retval.symmetric_transfer();
        }
        return h;
    }
 
    ret_value await_resume() {
        if constexpr(std::is_void_v<T>) {
            getInternal();
        } else {
            return getInternal();
        }
    }
 
 
    bool has_value() const {
        return _result != Result::not_set;
    }
 
 
    bool has_exception() const {
        return _result == Result::exception;
    }
 
 
 
    canceled_awaiter operator!() {return this;}
 
 
    template<typename X>
    typename promise<X>::notify forward_to(promise<X> &prom) & noexcept  {
        if (this->is_pending()) return {};
        switch (_result) {
            case Result::exception: return prom.reject(_exception);
            case Result::value:
                if constexpr(std::is_void_v<X>) {
                    return prom();
                } else {
                    if constexpr(std::is_reference_v<T>) {
                        return prom(*_value);
                    } else {
                        return prom(_value);
                    }
                }
            default:
            case Result::not_set:
                return prom.cancel();
 
        }
 
    }
    template<typename X>
    typename promise<X>::notify forward_to(promise<X> &&prom) & noexcept  {
        return forward_to(prom);
    }
 
 
    template<typename X>
    typename promise<X>::notify forward_to(promise<X> &prom) && noexcept  {
        if (this->is_pending()) return {};
        switch (_result) {
            case Result::exception: return prom.reject(_exception);
            case Result::value:
                if constexpr(std::is_void_v<X>) {
                    return prom();
                } else {
                    if constexpr(std::is_reference_v<T>) {
                        return prom(std::move(*_value));
                    } else {
                        return prom(std::move(_value));
                    }
                }
            default:
            case Result::not_set:
                return prom.cancel();
 
        }
 
    }
 
    template<typename X>
    typename promise<X>::notify forward_to(promise<X> &&prom) && noexcept  {
        return std::move(*this).forward_to(prom);
    }
 
 
 
    template<typename X, std::invocable<cast_ret_value> Fn>
    typename promise<X>::notify convert_to(promise<X> &prom, Fn &&convert) noexcept {
        if (this->is_pending()) return {};
 
        switch (_result) {
            case Result::exception: return prom.reject(_exception);
            case Result::value:
                if constexpr(std::is_void_v<std::invoke_result_t<Fn,cast_ret_value> >) {
                    if constexpr(std::is_reference_v<T>) {
                        std::forward<Fn>(convert)(_value);
                        return prom();
                    } else {
                        std::forward<Fn>(convert)(_value);
                        return prom();
                    }
                } else {
                    if constexpr(std::is_reference_v<T>) {
                        return prom(std::forward<Fn>(convert)(std::forward<cast_ret_value>(*_value)));
                    } else {
                        return prom(std::forward<Fn>(convert)(std::forward<cast_ret_value>(_value)));
                    }
                }
            default:
            case Result::not_set:
                return prom.cancel();
 
        }
    }
    template<typename X, std::invocable<cast_ret_value> Fn>
    typename promise<X>::notify convert_to(promise<X> &&prom, Fn &&convert) noexcept {
        return convert_to(prom, std::forward<Fn>(convert));
    }
 
 
 
protected:
 
    enum class State: char {
        //future is resolved
        resolved,
        //evaluation is deferred
        deferred,
        //future is pending  - no awaiter
        pending,
        //future is pending - awaiter is set
        awaited,
        //future is pending - deferred evaluation is current in progress
        evaluating,
 
    };
 
    enum class Result : char{
        //result is not set (yet?)
        not_set,
        //result contains value
        value,
        //result contains exception
        exception,
    };
 
    enum class RegAwtRes {
        //awaiter constructed, but future is resolved
        constructed_resolved,
        //awaiter constructed and ready
        constructed_ready,
        //future resolved, nothing happened
        resolved
 
    };
 
    using ChainPtr = future *;
 
    ChainPtr _chain = {};
    std::atomic<State> _state = {State::resolved}; //< by default, future is resolved in canceled state
    Result _result = Result::not_set; //< by default, future has no value
    bool _awaiter_cleanup = false;   //is set to true, if awaiter must be destroyed (in resolved state)
 
 
    //because deferred and awaited are mutually exclusive,
    //reuse single spcopy_ace for both functions
    union {
        awaiter_type _awaiter;
        deferred_eval_fn_type _deferred;
    };
 
 
    union {
        value_store_type _value;
        std::exception_ptr _exception;
        coro::function<T(), std::max(sizeof(value_store_type),sizeof(void *)*2)> _lambda;
    };
 
 
 
    void clearStorage() {
        switch (_result) {
            default: break;
            case Result::value: std::destroy_at(&_value);break;
            case Result::exception: std::destroy_at(&_exception);break;
        }
        _result = Result::not_set;
        check_awaiter_cleanup();
    }
 
    void wait_internal() {
        auto st = _state.load(std::memory_order_acquire);
        while (st != State::resolved) {
            if (st == State::deferred) {
                startDeferredEvaluation([](auto c){c();});
            } else {
                trace::on_block([&]{
                    _state.wait(st);
                },*this);
            }
            st = _state.load(std::memory_order_acquire);
        }
    }
 
    cast_ret_value getInternal() {
        switch (_result) {
            case Result::value:
                if constexpr(std::is_reference_v<T>) {
                    return std::forward<cast_ret_value>(*_value);
                } else {
                    return std::forward<cast_ret_value>(_value);
                }
 
            case Result::exception: std::rethrow_exception(_exception); break;
            default: break;
        }
        throw await_canceled_exception();
    }
 
 
 
    template<typename ResumeFn>
    bool startDeferredEvaluation(ResumeFn &&resume_fn) noexcept {
        //lock awaiter state (should be deferred previously)
        State new_state = State::evaluating;
        _state.exchange(new_state, std::memory_order_acquire);
        //call the deferred function and pass promise, pass coroutine to resume_fn
        resume_fn(_deferred(promise_t(this)));
        //destroy deferred function to leave place for awaiter
        std::destroy_at(&_deferred);
        //try to set pending - however, it can be already resolved now
        //return false, if resolved
        return _state.compare_exchange_strong(new_state, State::pending, std::memory_order_release);
 
    }
 
 
    template<std::invocable<promise_t> Fn>
    void setDeferredEvaluation(Fn &&fn) {
        //check return value - should return coroutine handle
        if constexpr(std::is_invocable_r_v<prepared_coro, Fn, promise_t> ) {
            //we expecting resolved state - other state is error
            State old = State::resolved;
            if (!_state.compare_exchange_strong(old,State::deferred, std::memory_order_relaxed)) {
                throw still_pending_exception();
            }
            //construct the function
            try {
                std::construct_at(&_deferred, std::forward<Fn>(fn));
                return;
            } catch (...) {
                //in case of exception, restore state
                _state.store(old, std::memory_order_relaxed);
                //and rethrow
                throw;
            }
        } else {
            //otherwise, wrap the function
            setDeferredEvaluation([xfn = std::move(fn)](promise_t prom) mutable->prepared_coro{
                xfn(std::move(prom));
                return {};
            });
        }
    }
 
    template<typename ... Args>
    void set_value(Args && ... args) {
        try {
            clearStorage();
            if constexpr(std::is_reference_v<T>) {
               std::construct_at(&_value, &args...);
            } else if constexpr(sizeof...(Args) == 1 && (invocable_r_exact<Args, value_store_type> && ...)) {
               new (&_value) value_store_type(args()...);
            } else {
               std::construct_at(&_value, std::forward<Args>(args)...);
            }
            _result = Result::value;
 
            if (_chain) {
                if constexpr(std::is_void_v<T>) {
                    _chain->set_value();
                } else if constexpr(std::is_reference_v<T>) {
                    _chain->set_value(*_value);
                } else if constexpr(std::is_copy_constructible_v<T>) {
                    _chain->set_value(_value);
                } /* else {
                    will cancel await (exception) as we cannot copy the valUE
                }*/
            }
        } catch (...) {
            set_exception(std::current_exception());
        }
    }
 
    void set_exception(std::exception_ptr e) {
        clearStorage();
        std::construct_at(&_exception, std::move(e));
        _result = Result::exception;
        if (_chain) _chain->set_exception(_exception);
    }
 
    template<typename SchedulerFn>
    void set_resolved(SchedulerFn &&schfn) {
        State st = _state.exchange(State::resolved);
        auto chain = _chain;
        _state.notify_all();
        if (st == State::awaited) {
            _awaiter_cleanup = true;
            schfn(_awaiter);
        }
        if (chain) chain->set_resolved(std::forward<SchedulerFn>(schfn));
    }
 
 
    void check_awaiter_cleanup() {
        if (_awaiter_cleanup) {
            std::destroy_at(&_awaiter);
            _awaiter_cleanup = false;
        }
    }
 
 
    template<std::invocable<> Awt, typename ResumeFn >
    RegAwtRes register_awaiter(Awt &&awt, ResumeFn &&resumeFn) {
        //lock awaiter slot
        State st = _state.exchange(State::evaluating);
        switch (st) {
            //already resolved?
            case State::resolved: _state.store(st); //restore state
                                  return RegAwtRes::resolved;
 
            case State::pending: //<still pending? move awaiter
                new(&_awaiter) auto(to_awaiter(awt));
                break;
            default:
            case State::evaluating:  //<locked - this is error
                throw still_pending_exception();
            case State::awaited:   //<already awaited? destroy previous awaiter and construct new one
                std::destroy_at(&_awaiter);
                new(&_awaiter) auto(to_awaiter(awt));
                break;
            case State::deferred: //<deferred ? perform evaluation and try again
                if (!startDeferredEvaluation(resumeFn)) return RegAwtRes::resolved;
                return register_awaiter(std::forward<Awt>(awt),std::forward<ResumeFn>(resumeFn));
        }
        st = State::evaluating; //replace evaluating with awaited
        if (!_state.compare_exchange_strong(st, State::awaited)) {
            //if failed, it should be resolved
            //mark that awaited must be clean up (always)
            _awaiter_cleanup = true;
            return RegAwtRes::constructed_resolved;
        }
        //awaiter has been set
        return RegAwtRes::constructed_ready;
    }
 
    template<std::invocable<> Fn>
    static awaiter_type to_awaiter(Fn &fn) {
        if constexpr (std::is_constructible_v<prepared_coro, std::invoke_result_t<Fn> >) {
            return std::move(fn);
        } else {
            return [fn = std::move(fn)]() mutable -> prepared_coro {
              fn();return {};
            };
        }
    }
 
    void checkInProgress() {
        if (is_in_progress()) throw still_pending_exception();
    }
 
 
 
    void attach(future *x) {
        future **ch = &_chain;
        while (*ch) ch = &((*ch)->_chain);
        *ch = x;
    }
 
 
    future *detach() {
        future *r = _chain;
        if (r) _chain = r->_chain;
        return r;
    }
 
    friend class _details::coro_promise_base<T>;
    friend class _details::wait_awaiter<future>;
    friend class promise<T>;
};
 
 
template<typename T>
class deferred_future: public future<T> {
public:
 
    using promise_t = typename future<T>::promise_t;
    using State = typename future<T>::State;
    using Result = typename future<T>::Result;
    using future<T>::future;
 
    template<std::invocable<promise_t> Fn>
    deferred_future(Fn &&fn) {
        this->setDeferredEvaluation(std::forward<Fn>(fn));
    }
    deferred_future(deferred_future &&other) {
        other.checkInProgress();
        if (other._state == State::deferred) {
            std::construct_at(&this->_deferred, std::move(other._deferred));
            this->_state = State::deferred;
        }
        switch (other._result) {
            case Result::value: std::construct_at(&this->_value, std::move(other._value)); break;
            case Result::exception: std::construct_at(&this->_exception, std::move(other._exception)); break;
            default: break;
        }
        this->_result = other._result;
    }
 
    deferred_future &operator=(deferred_future &&other) {
        if (this != &other){
            this->checkInProgress();
            other.checkInProgress();
            std::destroy_at(this);
            std::construct_at(this, std::move(other));
        }
        return *this;
    }
 
 
    void operator()(promise_t &&prom) & {
        State st = this->_state;
        if (st == State::deferred) {
            this->_deferred(std::move(prom));
            std::destroy_at(&this->_deferred);
            this->_state = State::resolved;
        } else if (st == State::resolved) {
            this->forward_to(prom);
        } else {
            throw still_pending_exception();
        }
    }
 
 
    void operator()(promise_t &&prom) && {
        State st = this->_state;
        if (st == State::deferred) {
            this->_deferred(std::move(prom));
            std::destroy_at(&this->_deferred);
            this->_state = State::resolved;
        } else if (st == State::resolved) {
            std::move(*this).forward_to(prom);
        } else {
            throw still_pending_exception();
        }
    }
 
 
};
 
namespace _details {
 
template<typename T>
class coro_promise_base: public trace::base_promise_type {
protected:
 
    future<T> *fut = nullptr;
 
    prepared_coro set_resolved()  {
        prepared_coro ret;
        auto tmp = std::exchange(fut, nullptr);
        tmp->set_resolved([&](auto &&fn){ret = fn();});
        return ret;
    }
    template<typename ... Args>
    void set_value(Args && ... args) const {
        if (fut) fut->set_value(std::forward<Args>(args)...);
        else {
            if constexpr ((std::invocable<Args> && ...)) {
                (args(), ...);
            }
        }
    }
 
    coro_promise_base() = default;
    coro_promise_base(const coro_promise_base &x) = delete;
    coro_promise_base &operator=(const coro_promise_base &) = delete;
    ~coro_promise_base() {
        if (fut) fut->set_resolved([](auto &&){});
    }
 
 
    void set_exception(std::exception_ptr e) {
        if (fut) fut->set_exception(std::move(e));
    }
 
 
public:
    void unhandled_exception() {
        if (fut) fut->set_exception(std::current_exception());
    }
 
};
 
 
template<typename T>
class coro_promise: public coro_promise_base<T> {
public:
 
    template<typename Arg>
    requires future_constructible<T, Arg>
    void return_value(Arg &&arg) {
        this->set_value(std::forward<Arg>(arg));
    }
 
 
};
 
template<>
class coro_promise<void>: public coro_promise_base<void> {
public:
    void return_void() {
        this->set_value();
    }
 
};
 
}
 
 
template<typename T>
class shared_future {
public:
 
    /*
     * +----------------+
     * |  shared_ptr    |---------------------> +----------------+
     * +----------------+                       |                |
     * | _next - l.list |                       |                |
     * +----------------+                       |    future<T>   |
     * | _state         |                       |                |
     * +----------------+                       |                |
     * |                |                       +----------------+
     * | _awaiter/cb    |                       | chain - l.list |
     * |                |                       +----------------+
     * +----------------+
     *
     *
     *
     */
 
 
    using value_type = typename future<T>::value_type;
    using value_store_type = typename future<T>::value_store_type;
    using cast_ret_value = typename future<T>::cast_ret_value;
    using ret_value = typename future<T>::ret_value;
    using awaiter_cb = function<prepared_coro()>;
    using wait_awaiter = _details::wait_awaiter<shared_future>;
    using canceled_awaiter = _details::has_value_awaiter<shared_future,false>;
 
 
    shared_future() {}
 
 
 
    template<typename Arg0, typename ... Args>
    requires (!std::is_same_v<std::decay_t<Arg0>, shared_future>)
    shared_future(Arg0 &&arg0, Args && ...args) {
        if constexpr(is_allocator<std::decay_t<Arg0> >) {
            static_assert(std::is_constructible_v<Shared, Args ...>, "Invalid arguments");
            _shared_future = std::allocate_shared<Shared>(arg0, std::forward<Args>(args)...);
        } else {
            static_assert(std::is_constructible_v<Shared, Arg0, Args ...>, "Invalid arguments");
            _shared_future = std::make_shared<Shared>(arg0, std::forward<Args>(args)...);
        }
        _shared_future->init_callback(_shared_future);
    }
 
    shared_future(shared_future &other):_shared_future(other._shared_future) {}
    shared_future(const shared_future &other):_shared_future(other._shared_future) {}
    shared_future &operator=(const shared_future &other) {
        this->_shared_future = other._shared_future;
        _state.store(State::unused, std::memory_order_relaxed);
        return *this;
    }
 
    ~shared_future() {
        check_in_progress();
    }
 
    promise<T> get_promise() {
        _shared_future = std::make_shared<Shared>();
        promise<T> p = _shared_future->get_promise();
        init();
        return p;
    }
 
 
    template<typename stl_allocator>
    promise<T> get_promise(stl_allocator &&allocator) {
        _shared_future = std::allocate_shared<Shared>(std::forward<allocator>(allocator));
        promise<T> p = _shared_future->get_promise();
        init();
        return p;
    }
 
 
    template<std::invocable<> Fn>
    void operator<<(Fn &&fn) {
        static_assert(std::is_invocable_r_v<coro::future<T>, Fn>);
        _shared_future = std::make_shared<Shared>(std::forward<Fn>(fn));
        init();
    }
 
 
    template<std::invocable<> Fn, typename std_allocator>
    void operator<<(std::tuple<Fn, std_allocator> && tpl) {
        static_assert(std::is_invocable_r_v<coro::future<T>, Fn>);
        _shared_future = std::allocate_shared<Shared>(
                std::forward<std_allocator>(std::get<std_allocator>(tpl)),
                std::forward<Fn>(std::get<Fn>(tpl)));
        init();
    }
 
 
 
    template<std::invocable<> Fn>
    bool set_callback(Fn &&fn) {
        auto st = _state.exchange(State::unused);
        if constexpr(std::is_constructible_v<prepared_coro, std::invoke_result_t<Fn> >) {
            _awaiter.emplace(std::forward<Fn>(fn));
        } else {
            _awaiter.emplace([fn = std::move(fn)]() mutable ->prepared_coro{
                fn(); return {};
            });
        }
        if (st == State::notified) return false;
        auto st2 = State::unused;
        if (_state.compare_exchange_strong(st2, State::awaited)) {
            if (st == State::unused) return _shared_future->register_target(this);
            return true;
        }
        return false;
    }
 
 
    template<std::invocable<> Fn>
    bool then(Fn &&fn) {
        if (!set_callback(std::forward<Fn>(fn))) {
            (*_awaiter)();
            return false;
        }
        return true;
    }
 
 
    template<std::invocable<> Fn>
    bool operator>>(Fn &&fn) {
        return when_resolved(std::forward<Fn>(fn));
    }
 
 
 
    wait_awaiter wait() {return this;}
 
 
    ret_value get() {
        wait();
        return _shared_future->get();
    }
 
 
    operator cast_ret_value (){
        wait();
        return *_shared_future;
    }
 
 
    bool is_pending() const {
        return _shared_future && _shared_future->is_pending();
    }
 
 
    bool is_in_progress() const {
        return _shared_future && _shared_future->is_in_progress();
    }
 
 
 
    bool is_awaited() const {
        return _state.load(std::memory_order_relaxed) == State::awaited;
    }
 
    bool await_ready() const {
        return !_shared_future || _shared_future->await_ready();
    }
 
 
    bool await_suspend(std::coroutine_handle<> h) {
        return set_callback([h]{return h;});
    }
 
    ret_value await_resume() {
        return _shared_future->await_resume();
    }
 
 
 
    void reset() {
        _shared_future.reset();
    }
 
 
    bool has_value() const {
        return _shared_future->has_value();
    }
 
 
    bool has_exception() const {
        return _shared_future->has_exception();
    }
 
 
    canceled_awaiter operator!()  {return this;}
 
 
 
 
protected:
 
    class Shared: public future<T> {
    public:
 
        using future<T>::future;
 
        static void init_callback(std::shared_ptr<Shared> self) {
            self->then([self = std::move(self)]() mutable -> prepared_coro{
                auto r = self->notify_targets();
                self.reset();
                return r;
            });
        }
 
        prepared_coro notify_targets() {
            auto n = _await_chain.exchange(disabled_slot());
            return n?notify_targets(n):prepared_coro{};
        }
 
        static prepared_coro notify_targets(shared_future *list) {
            if (list->_next) {
                auto c1 = notify_targets(list->_next);
                auto c2 = list->activate();
                if (c1) {
                    if (c2) {
                        c1();
                        return c2;
                    }
                    return c1;
                }
                return c2;
            } else {
                return list->activate();
            }
        }
 
        bool register_target(shared_future *item) {
            while (!_await_chain.compare_exchange_strong(item->_next, item)) {
                if (item->_next == disabled_slot()) return false;
            }
            return true;
        }
 
 
    protected:
        std::atomic<shared_future *> _await_chain = {};
    };
 
 
 
    enum class State: char {
        unused,
        awaited,
        notified
    };
 
 
    std::shared_ptr<Shared> _shared_future;
    shared_future *_next = nullptr;
    std::atomic<State> _state = {State::unused};
    std::optional<awaiter_cb> _awaiter;
 
    prepared_coro activate() {
        auto st = _state.exchange(State::notified);
        if (st == State::awaited) {
            return (*_awaiter)();
        }
        return {};
    }
 
    void wait_internal() {
        _shared_future->wait();
    }
 
 
    void check_in_progress() {
        if (_state.load(std::memory_order_relaxed) == State::awaited) {
            throw still_pending_exception();
        }
    }
 
 
    void init() {
        _shared_future->init_callback(_shared_future);
        _state.store(State::unused, std::memory_order_relaxed);
    }
 
 
    friend class _details::wait_awaiter<shared_future>;
 
 
    static shared_future<T> * disabled_slot() {return reinterpret_cast<shared_future<T> *>(1);}
 
 
};
 
 
#if 0
 
class future_with_callback {
public:
 
    template<typename Fut>
    future_with_callback(Fut &&fut) {
        this->fut = &fut;
        set_cb = [](void *fut, function<prepared_coro()>fun){
            using FutT = std::decay_t<Fut>;
            FutT *f = reinterpret_cast<FutT *>(fut);
            f->then(std::move(fun));
        };
    }
 
    template<std::invocable<> Fn>
    void operator>>(Fn &&fn) {
        if constexpr(std::is_same_v<std::invoke_result_t<Fn>, prepared_coro>) {
            set_cb(fut, std::forward<Fn>(fn));
        } else{
            set_cb(fut, [fn = std::move(fn)]()mutable -> prepared_coro {
                fn();
                return {};
            });
        }
    }
 
protected:
    void *fut;
    void (*set_cb)(void *fut, function<prepared_coro()>);
};
 
 
 
 
class all_of: public future<void> {
public:
 
 
    template<typename Iter>
    all_of(Iter from, Iter to) {
        result = get_promise();
        auto cb = [this]{if (--remain == 0) result();};
        while (from != to) {
            ++remain;
            static_cast<future_with_callback>(*from) >> cb;
            ++from;
        }
        cb();
    }
 
    all_of(std::initializer_list<future_with_callback> iter)
        :all_of(iter.begin(), iter.end()) {}
 
protected:
    promise<void> result = {};
    std::atomic<int> remain = {1};
 
};
 
#endif
#if 0
class any_of: public future<unsigned int> {
public:
 
    template<typename Iter>
    any_of(Iter from, Iter to) {
        cleanup = [=]{do_cleanup(from, to);};
        result = get_promise();
        unsigned int idx = 0;
        while (from != to) {
            static_cast<future_with_callback>(*from) >> [idx, this] {
                unsigned int r = notset;
                if (selected.compare_exchange_strong(r, idx)) {
                    finish();
                }
            };
            ++from;
            ++idx;
        }
        if (inited.fetch_add(2) > 0) {
            cleanup();
        }
    }
 
 
    any_of(std::initializer_list<future_with_callback> iter)
        :any_of(iter.begin(), iter.end()) {}
 
 
protected:
 
    void finish() {
        if (inited.fetch_add(1) > 1) {
            cleanup();
        }
        result(selected);
    }
 
 
    static constexpr unsigned int notset = std::bit_cast<unsigned int>(-1);
    promise<unsigned int> result = {};
    std::atomic<unsigned int> selected = {notset};
    std::atomic<int> inited = {0}; //0 - nothing, 1 - resolved before init, 2 - init waiting, 3 - resolved after init
    function<void(), 8*sizeof(void *)> cleanup;
 
    static void do_cleanup(auto from, auto to) {
        while (from != to) {
            static_cast<future_with_callback>(*from) >> []{return prepared_coro();};
            ++from;
        }
    }
};
#endif
 
 
 
}