How implement a coroutine suspend-running in a multi-thread trampoline scheduler when using a custom sender?

Issue chỉ cung cấp một ví dụ inline về counter_sender và nêu tên trampoline_scheduler, schedule(), then(), connect() và sync_wait(); hãy bắt đầu bằng cách kiểm tra các API này cùng các quy tắc về vòng đời của operation-state. Một cách giải quyết hữu ích sẽ định nghĩa một phương thức được hỗ trợ để tạm dừng và tiếp tục coroutine đang chạy qua trampoline đa luồng, được minh họa bằng một phiên bản hoạt động được của ví dụ với hành vi hoàn tất rõ ràng.

Something like this

#include <unifex/single_thread_context.hpp>
#include <unifex/trampoline_scheduler.hpp>
#include <unifex/let_value.hpp>
#include <unifex/just.hpp>
#include <unifex/sync_wait.hpp>
#include <unifex/then.hpp>

using namespace unifex;

class counter_sender {
public:
    counter_sender(int start, int end, trampoline_scheduler& scheduler)
        : current_(start), end_(end), scheduler_(scheduler) {}

    template<typename Receiver>
    struct operation {
        operation(int current, int end, 
                 trampoline_scheduler& scheduler, Receiver&& receiver)
            : current_(current)
            , end_(end)
            , scheduler_(scheduler)
            , receiver_((Receiver&&)receiver) {}

        void start() noexcept {
            if (current_ >= end_) {
                unifex::set_value(std::move(receiver_), current_);
                return;
            }

            auto next = current_ + 1;
            
            auto reschedule = 
                scheduler_.schedule() | 
                then([this, next]() {
                    auto new_op = operation{
                        next, 
                        end_, 
                        scheduler_, 
                        (Receiver&&)receiver_
                    };
                    new_op.start();
                });

            // restart
            connect(std::move(reschedule), receiver_).start();
        }

    private:
        int current_;
        int end_;
        trampoline_scheduler& scheduler_;
        Receiver receiver_;
    };

    template<typename Receiver>
    auto connect(Receiver&& receiver) {
        return operation<Receiver>{
            current_, end_, scheduler_, (Receiver&&)receiver
        };
    }

private:
    int current_;
    int end_;
    trampoline_scheduler& scheduler_;
};

void example() {
    trampoline_scheduler scheduler{};
    
    auto result = sync_wait(counter_sender{1, 5, scheduler});
    
    if (result) {
        std::cout << "Final count: " << *result << "\n";
    }
}