Is QtPromise based on Coroutine?

[seyedmmousavi]

My question is simple. Is QtPromise based on Coroutine?

[simonbrunel]

@seyedmmousavi No, it's not compatible with coroutines. I think @pwuertz had a look at adding support for coroutines, but I don't remember exactly the conclusions.

[pwuertz]

The conclusion was that QtPromise is a very convenient foundation for implementing an async coroutine framework. QtPromise::QPromise works well as a coroutine return type:

QtPromise::QPromise<void> async_func_1()
{
    co_await ...;
    co_return;
}

.. or as an awaitable within coroutine functions:

QtPromise::QPromise<void> async_func_2()
{
    co_await async_func_1();
}

[pwuertz]

Just need to provide some traits and operator definitions:

// Enable using QtPromise::QPromise<void> as coroutine return type
template <typename... Args>
struct std::coroutine_traits<QtPromise::QPromise<void>, Args...>
{
    struct promise_type
    {
        QtPromise::QPromise<void> get_return_object() noexcept
        {
            return QtPromise::QPromise<void>([&](const auto& resolve_, const auto& reject_) {
                resolve = resolve_;
                reject = reject_;
            });
        }

        constexpr std::suspend_never initial_suspend() const noexcept { return {}; }

        constexpr std::suspend_never final_suspend() const noexcept { return {}; }

        void return_void() const noexcept
        {
            (*resolve)();
        };

        void unhandled_exception() const noexcept
        {
            (*reject)(std::current_exception());
        }

    private:
        std::optional<QtPromise::QPromiseResolve<void>> resolve;
        std::optional<QtPromise::QPromiseReject<void>> reject;
    };
};


// Enable using non-void QtPromise::QPromise<T> as coroutine return type
template <typename T, typename... Args>
requires(!std::is_void_v<T>)
struct std::coroutine_traits<QtPromise::QPromise<T>, Args...>
{
    struct promise_type
    {
        QtPromise::QPromise<T> get_return_object() noexcept
        {
            return QtPromise::QPromise<T>([&](const auto& resolve_, const auto& reject_) {
                resolve = resolve_;
                reject = reject_;
            });
        }

        constexpr std::suspend_never initial_suspend() const noexcept { return {}; }

        constexpr std::suspend_never final_suspend() const noexcept { return {}; }

        void return_value(const T& value) const noexcept(std::is_nothrow_copy_constructible_v<T>)
        {
            (*resolve)(value);
        }

        void return_value(T&& value) const noexcept(std::is_nothrow_move_constructible_v<T>)
        {
            (*resolve)(std::move(value));
        }

        void unhandled_exception() const noexcept
        {
            (*reject)(std::current_exception());
        }

    private:
        std::optional<QtPromise::QPromiseResolve<T>> resolve;
        std::optional<QtPromise::QPromiseReject<T>> reject;
    };
};


// Enable using non-void QtPromise::QPromise<T> in co_await expressions
template <typename T> inline
auto operator co_await(QtPromise::QPromise<T> promise) noexcept
{
    struct awaiter
    {
        QtPromise::QPromise<T> promise;
        const T * value = nullptr;
        std::exception_ptr eptr = nullptr;

        constexpr bool await_ready() const noexcept { return false; }

        void await_suspend(std::coroutine_handle<> cont) noexcept
        {
            promise.then(
                [this, cont](const T& v) { value = std::addressof(v); cont(); },
                [this, cont]() { eptr = std::current_exception(); cont(); }
                );
        }

        T await_resume() const
        {
            if (eptr) { std::rethrow_exception(eptr); }
            return *value;
        }
    };

    return awaiter{ .promise = std::move(promise) };
}


// Enable using QtPromise::QPromise<void> in co_await expressions
template <> inline
auto operator co_await(QtPromise::QPromise<void> promise) noexcept
{
    struct awaiter
    {
        QtPromise::QPromise<void> promise;
        std::exception_ptr eptr = nullptr;

        constexpr bool await_ready() const noexcept { return false; }

        void await_suspend(std::coroutine_handle<> cont) noexcept
        {
            promise.then(
                cont,
                [this, cont]() { eptr = std::current_exception(); cont(); }
                );
        }

        void await_resume() const
        {
            if (eptr) { std::rethrow_exception(eptr); }
        }
    };

    return awaiter{ .promise = std::move(promise) };
}