Build Async
C++ That
Actually Makes
Sense.

// Each async step is its own function.
// Shared state needs shared_ptr to stay alive.
// "Retry on failure" requires a state machine.

struct Request
    : std::enable_shared_from_this<Request>
{
    tcp::socket   socket_;
    tcp::resolver resolver_;
    tcp::timer    timer_;
    std::string   host_, body_;
    char          buf_[4096];
    int           retries_{ 0 };

    void run() { do_resolve(); }

    void do_resolve() {
        auto self = shared_from_this();
        resolver_.async_resolve(host_, "80",
            [self](error_code ec,
                   tcp::resolver::results_type r) {
                if (ec) return self->retry(ec);
                self->do_connect(r);
            });
    }

    void do_connect(tcp::resolver::results_type eps) {
        auto self = shared_from_this();
        async_connect(socket_, eps,
            [self](error_code ec, tcp::endpoint) {
                if (ec) return self->retry(ec);
                self->do_write();
            });
    }

    void do_write() {
        auto self = shared_from_this();
        async_write(socket_, buffer(body_),
            [self](error_code ec, size_t) {
                if (ec) return self->retry(ec);
                self->do_read();
            });
    }

    void do_read() {
        auto self = shared_from_this();
        socket_.async_read_some(buffer(buf_),
            [self](error_code ec, size_t n) {
                if (ec) return self->retry(ec);
                process(self->buf_, n);
            });
    }

    void retry(error_code ec) {
        if (++retries_ > 3) return on_fail(ec);
        timer_.expires_after(seconds(retries_));
        timer_.async_wait(
            [self = shared_from_this()](error_code) {
                self->do_resolve();
            });
    }
};

// No class. No shared_ptr.
// Retry is just a loop.
// Reads exactly like what it does.

capy::task<> fetch(
    corosio::io_context& ioc,
    std::string host,
    std::string body)
{
    for (int attempt = 1; attempt <= 3; ++attempt)
    {
        corosio::tcp_socket sock(ioc);
        corosio::resolver   res(ioc);

        auto [rec, eps] =
            co_await res.resolve(host, "80");
        if (rec) {
            co_await sleep(ioc, seconds(attempt));
            continue;
        }

        auto [cec] = co_await sock.connect(eps);
        if (cec) {
            co_await sleep(ioc, seconds(attempt));
            continue;
        }

        auto [wec, wn] =
            co_await capy::write(sock, buffer(body));
        if (wec) {
            co_await sleep(ioc, seconds(attempt));
            continue;
        }

        char buf[4096];
        auto [ec, n] =
            co_await sock.read_some(buffer(buf));
        if (!ec) { process(buf, n); co_return; }
    }
}