#include <coroutine>
#include <functional>
#include <iostream>

struct promise;

struct coroutine: std::coroutine_handle<promise>
{
    using promise_type = ::promise;
};

struct promise
{
    coroutine get_return_object() { return {coroutine::from_promise(*this)}; }
    std::suspend_always initial_suspend() noexcept { return {}; }
    std::suspend_always final_suspend() noexcept { return {}; }
    void return_void() {}
    void unhandled_exception() {}
};

coroutine function()
{
    std::cout << "cogito, ";
    co_await std::suspend_always{};
    std::cout << "ergo, ";
    co_await std::suspend_always{};
    std::cout << "sum!\n";
}

auto lambda = [] -> coroutine
{
    std::cout << "cogito, ";
    co_await std::suspend_always{};
    std::cout << "ergo, ";
    co_await std::suspend_always{};
    std::cout << "sum!\n";
};

struct functor
{
    coroutine operator()()
    {
        std::cout << "cogito, ";
        co_await std::suspend_always{};
        std::cout << "ergo, ";
        co_await std::suspend_always{};
        std::cout << "sum!\n";
    }
};

struct struct_type
{
    coroutine method()
    {
        std::cout << "cogito, ";
        co_await std::suspend_always{};
        std::cout << "ergo, ";
        co_await std::suspend_always{};
        std::cout << "sum!\n";
    }
};

template<typename Callable, typename... Args>
void test(Callable f, Args... args)
{
    auto c = std::invoke(f, args...);
    while (!c.done())
        c.resume();
}

int main()
{
    test(function);
    test(lambda);
    test(functor{});
    test(&struct_type::method, struct_type{});
}