I'm starting to consider that this could be mapped to a scala.util.Try somehow instead... It would be much nicer to have pattern matching available.

Usually you have something like this:
```
vertx.createHttpServer().requestHandler(rm).listen(8080, { ar =>
  if (ar.succeeded) {
    doSomethingWithHttpServer(ar.result)
  } else {
    handleError(ar.cause)
  }
})
```

The same with a Try:
```
vertx.createHttpServer().requestHandler(rm).listen(8080, {
  case Success(result) => doSomethingWithHttpServer(result)
  case Failure(ex) => handleError(ex)
})
```

WDYT? As it might imply a lot of changes again (could it be done via implicit conversions somehow?) and would probably cause a lot of breaking changes in user code, shall we plan to release that now or shall we consider doing that after 0.2.0 release?

You might have seen the function `implicit def tryToAsyncResultHandler[X]` in FunctionConverters, but using it in client code still is a pain. As you need to map a Try[X] => Unit to AsyncResult[X] => Unit, you need to tell the compiler the complete method signature like this:
```
import org.vertx.scala.core.FunctionConverters._

vertx.createHttpServer().requestHandler(rm).listen(8080, {
  case Success(result) => doSomethingWithHttpServer(result)
  case Failure(ex) => handleError(ex)
}: Try[HttpServer] => Unit)
```