std::noop_coroutine

#include <coroutine>
#include <utility>
#include <iostream>
 
template<class T>
struct tarea {
    struct tipo_promesa {
        auto get_return_object() {
            return tarea(std::coroutine_handle<tipo_promesa>::from_promise(*this));
        }
        std::suspend_always initial_suspend() { return {}; }
        struct esperador_final {
            bool await_ready() noexcept { return false; }
            void await_resume() noexcept {}
            std::coroutine_handle<> await_suspend(std::coroutine_handle<tipo_promesa> h) noexcept {
                // esperador_final::await_suspend se llama cuando la ejecución de la
                // corrutina actual (referida por 'h') está a punto de terminar.
                // Si la corrutina actual se reanudó por otra corrutina vía
                // co_await get_task(), se ha almacenado un identificador a esa corrutina
                // como h.promise().previous. En ese caso, se devuelve el identificador para reanudar
                // la corrutina previa.
                // De lo contrario, se devuelve noop_coroutine(), cuya reanudación no hace nada.
 
                auto previous = h.promise().previous;
                if (previous) {
                    return previous;
                } else {
                    return std::noop_coroutine();
                }
            }
        };
        esperador_final final_suspend() noexcept { return {}; }
        void unhandled_exception() { throw; }
        void return_value(T value) { result = std::move(value); }
        T result;
        std::coroutine_handle<> previous;
    };
 
    tarea(std::coroutine_handle<tipo_promesa> h) : corrutina(h) {}
    tarea(tarea&& t) = delete;
    ~tarea() { corrutina.destroy(); }
 
    struct esperador {
        bool await_ready() { return false; }
        T await_resume() { return std::move(corrutina.promise().result); }
        auto await_suspend(std::coroutine_handle<> h) {
            corrutina.promise().previous = h;
            return corrutina;
        }
        std::coroutine_handle<tipo_promesa> corrutina;
    };
    esperador operator co_await() { return esperador{corrutina}; }
    T operator()() {
        corrutina.resume();
        return std::move(corrutina.promise().result);
    }
private:
    std::coroutine_handle<tipo_promesa> corrutina;
};
 
tarea<int> captar_aleatorio() {
    std::cout << "en captar_aleatorio()\n";
    co_return 4;
}
tarea<int> prueba() {
    tarea<int> v = captar_aleatorio();
    tarea<int> u = captar_aleatorio();
    std::cout << "en prueba()\n";
    int x = (co_await v + co_await u);
    co_return x;
}
 
int main() {
    tarea<int> t = prueba();
    int result = t();
    std::cout << result << '\n';
}