Здравствуйте, so5team, Вы писали:

S>А можно пример? Типа вот с КА было вот так, а с короутинами -- вот так.

вот гопота нагенерила.
Было:

#include <iostream>
#include <string>

enum class State { Idle, Started, Processing, Stopped };
 
class StateMachine {
    State state = State::Idle;

public:
    void next() {
        switch (state) {
            case State::Idle:
                std::cout << "State: Idle\n";
                state = State::Started;
                break;
            case State::Started:
                std::cout << "State: Started\n";
                state = State::Processing;
                break;
            case State::Processing:
                std::cout << "State: Processing\n";
                state = State::Stopped;
                break;
            case State::Stopped:
                std::cout << "State: Stopped\n";
                break;
        }
    }

    bool isDone() const {
        return state == State::Stopped;
    }
};

int main() {
    StateMachine sm;
    while (!sm.isDone()) {
        sm.next();
    }
    sm.next(); // финальное состояние
}

Стало:

#include <iostream>
#include <coroutine>
#include <string>

struct StateMachine {
    struct promise_type;
    using handle_type = std::coroutine_handle<promise_type>;

    struct promise_type {
        std::string value;
        auto get_return_object() { return StateMachine{handle_type::from_promise(*this)}; }
        auto initial_suspend() { return std::suspend_always{}; }
        auto final_suspend() noexcept { return std::suspend_always{}; }
        void return_void() {}
        void unhandled_exception() { std::exit(1); }
        auto yield_value(std::string s) {
            value = s;
            return std::suspend_always{};
        }
    };

    handle_type coro;

    explicit StateMachine(handle_type h) : coro(h) {}
    ~StateMachine() { if (coro) coro.destroy(); }

    bool next() {
        if (!coro.done()) {
            coro.resume();
            return true;
        }
        return false;
    }

    std::string value() const {
        return coro.promise().value;
    }
};

StateMachine runMachine() {
    co_yield "Idle";
    co_yield "Started";
    co_yield "Processing";
    co_yield "Stopped";
}

int main() {
    auto sm = runMachine();
    while (sm.next()) {
        std::cout << "State: " << sm.value() << '\n';
    }
}

Пока второй вариант многословней. Но и надо понимать, что StateMachine однотипный для всех корутин. Заново его писать не придётся. Основная бизнес-логика сосредоточена в runMachine. Тогда как в первом примере логика больше перенесена в StateMachine.