Question... how should I properly convert a piece ...

# getting-started

[plombardi]

Question... how should I properly convert a piece of code like this from Java to Kotlin? IntelliJ is failing to convert it properly

FileSystem fs = vertx.fileSystem();
    Future<Void> startFuture = Future.future();

    Future<Void> fut1 = Future.future();
    String file = "/tmp/" + UUID.randomUUID().toString();
    fs.createFile(file, fut1.completer());
    fut1.compose( v -> {
      Future<Void> fut2 = Future.future();
      System.out.println("Step 1");
      fs.writeFile(file, Buffer.buffer("Hello World!"), fut2.completer());
      return fut2;
    }).compose( v -> {
      Future<Boolean> fut3 = Future.future();
      fs.exists(file, fut3.completer());
      System.out.println("Step 2");
      return fut3;
    }).compose( exists -> {
      Future<Buffer> fut4 = Future.future();

      if (exists) {
        fs.readFile(file, fut4.completer());
        System.out.println("Step 3");
      } else {
        fut4.fail("");
      }

      return fut4;
    }).compose( buf -> System.out.println(buf.toString()), startFuture);

IntelliJ spits out:

val fs = vertx.fileSystem()
    val startFuture = Future.future<Void>()

    val fut1 = Future.future<Void>()
    val file = "/tmp/" + UUID.randomUUID().toString()
    fs.createFile(file, fut1.completer())
    fut1.compose<Void>({ v ->
                         val fut2 = Future.future<Void>()
                         println("Step 1")
                         fs.writeFile(file, Buffer.buffer("Hello World!"), fut2.completer())
                         fut2
                       }).compose<Boolean>({ v ->
                                             val fut3 = Future.future<Boolean>()
                                             fs.exists(file, fut3.completer())
                                             println("Step 2")
                                             fut3
                                           }).compose<Buffer>({ exists ->
                                                                val fut4 = Future.future<Buffer>()

                                                                if (exists!!) {
                                                                  fs.readFile(file, fut4.completer())
                                                                  println("Step 3")
                                                                } else {
                                                                  fut4.fail("")
                                                                }

                                                                fut4
                                                              }).compose<Void>({ buf -> println(buf.toString()) }, startFuture)

which is no good (complains of type inference failures)