Coroutine Test

coro.cpp

#include <iostream>
#include <experimental/coroutine>

struct coroutine_type {
    struct promise_type {
        int _value;
        coroutine_type get_return_object() { return { *this }; }
        auto initial_suspend() { return std::experimental::suspend_never{}; }
        auto final_suspend() { return std::experimental::suspend_always{}; }
        void unhandled_exception() { std::terminate(); }
        void return_value(int val) { 
            _value = val; 
        }
    };
    coroutine_type() = default;
    coroutine_type(const coroutine_type&) = default;
    ~coroutine_type() { 
        _coro.destroy(); 
    }
    void resume() { _coro.resume(); }
    int get() { return _coro.promise()._value; }
private:
    using HDL = std::experimental::coroutine_handle<promise_type>;
    coroutine_type(promise_type& p) : _coro(HDL::from_promise(p)) {}
    HDL _coro;
};

coroutine_type coroutine() {
    std::cout << "before suspension" << "\n";
    co_await std::experimental::suspend_always{};
    std::cout << "resumed" << "\n";
    co_return 42;
}

int main()
{
    auto coro = coroutine();
    coro.resume();
    std::cout << coro.get() << "\n";
    return 0;
}

coro_v2.cpp

#include <iostream>
#include <experimental/coroutine>

struct generate_type {
        struct promise_type {
                int _value;
                generate_type get_return_object() { return {*this}; }
                auto initial_suspend() { return std::experimental::suspend_never{}; }
                auto final_suspend() { return std::experimental::suspend_never{}; }
                void unhandled_exception() { std::terminate(); }
                void return_void() {}
                auto yield_value(int val) {
                        _value = val;
                        return std::experimental::suspend_always{};
                }
        };
        generate_type() = default;
        generate_type(const generate_type&) = default;
        ~generate_type() { _coro.destroy(); }
        void resume() { _coro.resume(); }
        int get() { return _coro.promise()._value; }
private:
        using HDL = std::experimental::coroutine_handle<promise_type>;
        generate_type(promise_type& p) : _coro(HDL::from_promise(p)) {}
        HDL _coro;
};

generate_type func() {
        for (int i = 0; i < 3; i++)
                co_yield i;
}

int main()
{
        auto gen = func();
        std::cout << gen.get() << "\n";
        gen.resume();
        std::cout << gen.get() << "\n";
        gen.resume();
        std::cout << gen.get() << "\n";
        return 0;
}

Makefile

all:
        clang coro.cpp -std=c++2a -stdlib=libc++ -lc++ -fcoroutines-ts -o coro
        clang coro_v2.cpp -std=c++2a -stdlib=libc++ -lc++ -fcoroutines-ts -o coro_v2