Wife says: "I can't believe it works"

Just a teaser:

int main()
{
  try
  {
    using asio::ip::tcp;
    using namespace boost::lambda;

    asio::io_service io_service;
    tcp::acceptor acceptor(io_service,
        tcp::endpoint(tcp::v4(), 54321));

    const int max_clients = 100;
    coroutine coro[max_clients];
    std::auto_ptr<tcp::socket> socket[max_clients];
    asio::error_code ec[max_clients];
    std::size_t length[max_clients];
    boost::array<char, 1024> data[max_clients];

    // Kick off all the coroutines.
    int n = -1;
    for (int i = 0; i < max_clients; ++i)
    {
      socket[i].reset(new tcp::socket(io_service));
      io_service.post(
          unlambda((
            var(n) = i
          )));
    }

    for (; io_service.run_one() > 0; n = -1)
    {
      if (n != -1)
      {
        reenter (coro[n])
        {
        entry:
          for (;;)
          {
            // Wait for a client to connect.
            yield acceptor.async_accept(
                *socket[n],
                unlambda((
                  var(n) = n,
                  var(ec[n]) = _1
                )));

            // Echo at will.
            while (!ec[n])
            {
              yield socket[n]->async_read_some(
                  asio::buffer(data[n]),
                  unlambda((
                    var(n) = n,
                    var(ec[n]) = _1,
                    var(length[n]) = _2
                  )));

              if (!ec[n])
              {
                yield asio::async_write(
                    *socket[n],
                    asio::buffer(data[n], length[n]),
                    unlambda((
                      var(n) = n,
                      var(ec[n]) = _1
                    )));
              }
            }

            // Clean up before accepting next client.
            socket[n]->close();
          }
        }
      }
    }
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }
}

One function. One fully asynchronous server. Bog standard C++.