### composed

Creates an initiation function object that may be used to launch an asynchronous operation with a stateful implementation.

    template<
        typename... Signatures,
        typename Implementation,
        typename... IoObjectsOrExecutors>
    auto composed(
        Implementation && implementation,
        IoObjectsOrExecutors &&... io_objects_or_executors);

The `composed` function simplifies the implementation of composed asynchronous operations automatically by wrapping a stateful function object for use as an initiation function object.

##### Parameters

implementation

  A function object that contains the implementation of the composed asynchronous operation. The first argument to the function object is a non-const reference to the enclosing intermediate completion handler. The remaining arguments are any arguments that originate from the completion handlers of any asynchronous operations performed by the implementation.

io_objects_or_executors

  Zero or more I/O objects or I/O executors for which outstanding work must be maintained.

##### Per-Operation Cancellation

By default, terminal per-operation cancellation is enabled for composed operations that are implemented using `composed`. To disable cancellation for the composed operation, or to alter its supported cancellation types, call the `self` object's `reset_cancellation_state` function.

##### Example:

    struct async_echo_implementation
    {
      tcp::socket& socket_;
      asio::mutable_buffer buffer_;
      enum { starting, reading, writing } state_;

      template <typename Self>
      void operator()(Self& self,
          asio::error_code error,
          std::size_t n)
      {
        switch (state_)
        {
        case starting:
          state_ = reading;
          socket_.async_read_some(
              buffer_, std::move(self));
          break;
        case reading:
          if (error)
          {
            self.complete(error, 0);
          }
          else
          {
            state_ = writing;
            asio::async_write(socket_, buffer_,
                asio::transfer_exactly(n),
                std::move(self));
          }
          break;
        case writing:
          self.complete(error, n);
          break;
        }
      }
    };

    template <typename CompletionToken>
    auto async_echo(tcp::socket& socket,
        asio::mutable_buffer buffer,
        CompletionToken&& token)
      -> decltype(
        asio::async_initiate<CompletionToken,
          void(asio::error_code, std::size_t)>(
            asio::composed(
              async_echo_implementation{socket, buffer,
                async_echo_implementation::starting}, socket),
            token))
    {
      return asio::async_initiate<CompletionToken,
        void(asio::error_code, std::size_t)>(
          asio::composed(
            async_echo_implementation{socket, buffer,
              async_echo_implementation::starting}, socket),
          token, asio::error_code{}, 0);
    }

##### Requirements

Header: `asio/composed.hpp`

Convenience header: `asio.hpp`