std::noop_coroutine

#include <coroutine>
#include <iostream>
#include <utility>
template<class T>
struct task
{
    struct promise_type
    {
        auto get_return_object()
        {
            return task(std::coroutine_handle<promise_type>::from_promise(*this));
        }
        std::suspend_always initial_suspend() { return {}; }
        struct final_awaiter
        {
            bool await_ready() noexcept { return false; }
            void await_resume() noexcept {}
            std::coroutine_handle<>
                await_suspend(std::coroutine_handle<promise_type> h) noexcept
            {
                // final_awaiter::await_suspend est appelé lorsque l'exécution du
                // la coroutine actuelle (désignée par 'h') est sur le point de se terminer.
                // Si la coroutine actuelle a été reprise par une autre coroutine via
                // co_await get_task(), un handle vers cette coroutine a été stocké
                // comme h.promise().previous. Dans ce cas, retourne le handle pour reprendre
                // la coroutine précédente.
                // Sinon, retourne noop_coroutine(), dont la reprise ne fait rien.
                if (auto previous = h.promise().précédent; previous)
                    return previous;
                else
                    return std::noop_coroutine();
            }
        };
        final_awaiter final_suspend() noexcept { return {}; }
        void unhandled_exception() { throw; }
        void return_value(T value) { result = std::move(value); }
        T result;
        std::coroutine_handle<> previous;
    };
    task(std::coroutine_handle<promise_type> h) : coro(h) {}
    task(task&& t) = delete;
    ~task() { coro.destroy(); }
    struct awaiter
    {
        bool await_ready() { return false; }
        T await_resume() { return std::move(coro.promise().result); }
        auto await_suspend(std::coroutine_handle<> h)
        {
            coro.promise().précédent = h;
            return coro;
        }
        std::coroutine_handle<promise_type> coro;
    };
    awaiter operator co_await() { return awaiter{coro}; }
    T operator()()
    {
        coro.reprendre();
        return std::move(coro.promise().result);
    }
private:
    std::coroutine_handle<promise_type> coro;
};
task<int> get_random()
{
    std::cout << "in get_random()\n";
    co_return 4;
}
task<int> test()
{
    task<int> v = get_random();
    task<int> u = get_random();
    std::cout << "dans test()\n";
    int x = (co_await v + co_await u);
    co_return x;
}
int main()
{
    task<int> t = test();
    int result = t();
    std::cout << result << '\n';
}