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++.

User-friendly compile errors for templates in C++0x

The C++0x features decltype, static_assert and the "new function declarator syntax" can be combined with our old friend SFINAE to generate nicer template compile errors.

As a simple example, consider a container class similar to std::set. Normally if you just declare a variable

set<my_type> s;

it will compile without error even if my_type has no operator<. You will only get an error when you try to call a set member function, such as insert(). Worse still, the errors tend to be quite verbose. (Too verbose for me to want to paste here, anyway.) It would be really nice to generate a short, readable error at the point of the original variable declaration. Let's see how we can do just that in C++0x.

First, we need to write a compile-time test for operator<. This is where SFINAE, decltype and the new function declarator syntax come together. We write the test function:

auto less_than_test(const T* t)
  -> decltype(*t < *t, char(0));

and the fallback overload:

std::array<char, 2> less_than_test(...);

The trick here is that, according to the C++0x grammar, we have:

decltype ( expression )

and

expression:
    assignment-expression
    expression , assignment-expression

This means that the first overload uses decltype to do two things: it makes the overload a viable candidate only if the expression *t < *t is valid; and it says the overload returns a char.

Second, we can use sizeof to determine which of the overloads is selected for a given type T, and static_assert to generate a readable error:

template <typename T>
class set
{
public:
  static_assert(
      sizeof(less_than_test((T*)0)) == 1,
      "type T must provide operator<");
};

The g++ 4.4 compiler then gives the following output on the original variable declaration:

test.cpp: In instantiation of set<my_type>
test.cpp:21:   instantiated from here
test.cpp:13: error: static assertion failed:
    "type T must provide operator<"

It works with function templates too. To add a check to Asio's async_read function's ReadHandler parameter, I could write the check as follows:

template <typename T>
auto read_handler_test(T* t)
  -> decltype(
      (*t)(
        *(const error_code*)0,
        (const std::size_t)0),
      char(0));

std::array<char, 2> read_handler_test(...);

template <..., typename ReadHandler>
void async_read(..., ReadHandler handler)
{
  static_assert(
      sizeof(read_handler_test(&handler)) == 1,
      "ReadHandler type requirements not met");
  ...
}

Perhaps with a touch of macro magic, checks of this sort could become quite easy to write.

"Hang on, what about C++0x concepts?" I hear you ask. What are they? ;-)