task<T> implementation about act HOT 6 CLOSED

#include <iostream>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/write.hpp>
#include <act/socket.hpp>
#include <act/write.hpp>
#include <act/acceptor.hpp>
#include <experimental/coroutine>

namespace asio = boost::asio;

namespace std::experimental
{
    template<class... T>
    struct coroutine_traits<void, T...>
    {
        struct promise_type
        {
            void get_return_object() {}

            suspend_never initial_suspend() noexcept
            {
                return {};
            }

            suspend_never final_suspend() noexcept
            {
                return {};
            }

            void return_void() noexcept {}
        };
    };
}

void session(asio::ip::tcp::socket sock)
{
    try
    {
        char buf[1024];
        std::cout << "connected: " << sock.remote_endpoint() << std::endl;
        for (; ; )
        {
            act::error_code ec;
            auto len = co_await act::read_some(sock, asio::buffer(buf), ec);
            if (ec == asio::error::eof)
                co_return;
            co_await act::write(sock, asio::buffer(buf, len));
        }
    }
    catch (std::exception& e)
    {
        std::cout << "error: " << sock.remote_endpoint() << ": " << e.what() << std::endl;
    }
}

void server(asio::io_context& io, unsigned short port)
{
    asio::ip::tcp::endpoint endpoint{asio::ip::tcp::v4(), port};
    asio::ip::tcp::acceptor acceptor{io, endpoint};
    asio::ip::tcp::socket sock{io};
    std::cout << "server running at: " << endpoint << std::endl;
    for (; ; )
    {
        co_await act::accept(acceptor, sock);
        session(std::move(sock));
    }
}

int main(int argc, char *argv[])
{
    asio::io_context io;
    server(io, std::atoi(argv[1]));
    io.run();

    return EXIT_SUCCESS;
}