Vert.x with RxJava

On my current project Vert.x is used with RxJava and I don't understand why?

What does RxJava offer on top of what Vert.x offers.

There is this but it doesn't answer my question.

The core Vert.x API uses callbacks to deal with asynchronous operations, which can be difficult to compose (chain together). For example, deploying a bunch of Verticles in sequence looks like this using callbacks:

vertx.deployVerticle(MyClass1.class.getCanonicalName(), result1 -> {
  if (result2.succeeded()) {
    vertx.deployVerticle(MyClass2.class.getCanonicalName(), result2 -> {
      if (result2.suceeded()) {
        vertx.deployVerticle(MyClass3.class.getCanonicalName(), result3 -> {
          if (result3.succeeded()) {
            System.out.println("Deployed the verticles");
          } else {
            System.err.println("Failed to deploy verticle " + result3.cause());
          }
        });
       } else {
         System.err.println("Failed to deploy verticle " + result2.cause());
       }
    });
  } else {
    System.out.println("Failed to deploy verticle " + result1.cause());
  }
);

The equivalent code using the Rxified Vert.x API would be this:

vertx.rxDeployVerticle(MyClass1.class.getCanonicalName())
    .flatMap(ign -> vertx.rxDeployVerticle(MyClass2.class.getCanonicalName()))
    .flatMap(ign -> vertx.rxDeployVerticle(MyClass3.class.getCanonicalName()))
    .subscribe(
        ign -> System.out.println("Deployed the verticles"),
        err -> System.err.println("Failed to deploy verticle " + err)
    );

RxJava makes it much easier to deal with composing asynchronous operations like this. Granted, this example is a little bit contrived (you could definitely clean up the callback version to be more readable), but it gives you an idea of how simple it is to chain the operations with RxJava. RxJava has a very rich set of operators for combining and transforming asynchronous operations, which allows you express complex logic with very little code. It's just not possible to do that with the core Vert.x API.

Vert.x 4.0 is going to add a Future-based API to core Vert.x, which will reduce the need for RxJava for simpler workflows (like the example above), but more complex flows will still benefit from it.