#### Stackless Coroutines

The `coroutine` class provides support for stackless coroutines. Stackless coroutines enable programs to implement asynchronous logic in a synchronous manner, with minimal overhead, as shown in the following example:

    struct session : asio::coroutine
    {
      boost::shared_ptr<tcp::socket> socket_;
      boost::shared_ptr<std::vector<char> > buffer_;

      session(boost::shared_ptr<tcp::socket> socket)
        : socket_(socket),
          buffer_(new std::vector<char>(1024))
      {
      }

      void operator()(asio::error_code ec = asio::error_code(), std::size_t n = 0)
      {
        if (!ec) reenter (this)
        {
          for (;;)
          {
            yield socket_->async_read_some(asio::buffer(*buffer_), *this);
            yield asio::async_write(*socket_, asio::buffer(*buffer_, n), *this);
          }
        }
      }
    };

The `coroutine` class is used in conjunction with the pseudo-keywords `reenter`, `yield` and `fork`. These are preprocessor macros, and are implemented in terms of a `switch` statement using a technique similar to Duff's Device. The `coroutine` class's documentation provides a complete description of these pseudo-keywords.

###### See Also

coroutine, HTTP Server 4 example, Stackful Coroutines.