на шарпах

понимаю, что чат не тот

наверное вот так будет ещё ближе к тому что я хотел

CompletableFuture<Integer> mustReturn42() {
  CompletableFuture<Integer> fastRequest =
      CompletableFuture.supplyAsync(() -> new Random().nextBoolean() ? 42 : 1);
  CompletableFuture<Integer> slowRequest =
      CompletableFuture.supplyAsync(
          () -> {
            try {
              Thread.sleep(1000);
            } catch (InterruptedException e) {
              throw new RuntimeException(e);
            }
            return 41;
          });

    return fastRequest.thenApply(
        result -> {
          if (result == 42) {
            return 42;
          } else {
            try {
              return slowRequest.get() + result;
            } catch (InterruptedException | ExecutionException e) {
              throw new RuntimeException(e);
            }
          }
        });
}

ощущуение что пхоже как аналог Optional.orElse...когда по else высчитывается всегда, но если опшионал есть, то возьми его)

да, именно так, но применительно к CF )

я бы поигрался методами
thenCompose()
.handle
и на крайняк Join

да это всё не то

(

handle - это же вообще для исключения

блеаааааа походу вот так нужно:

CompletableFuture<Integer> fastResult = new CompletableFuture<>();
    CompletableFuture<Void> fastRequest =
        CompletableFuture.runAsync(
            () -> {
              if (new Random().nextBoolean()) {
                fastResult.complete(42);
              } else {
                fastResult.complete(1);
              }
            });
    CompletableFuture<Integer> slowRequest =
        CompletableFuture.supplyAsync(
            () -> {
              try {
                Thread.sleep(1000);
              } catch (InterruptedException e) {
                throw new RuntimeException(e);
              }
              return 41;
            });

    return fastRequest.thenCompose(
        ignore -> {
          try {
            if (fastResult.get() == 42) {
              return CompletableFuture.completedFuture(42);
            } else {
              return slowRequest.thenCombine(fastResult, (l, r) -> l + r);
            }
          } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
          }
        });

а потом они ещё спрашиваю, а что нам Котлин даст?

неее...там же в него передаётся результат(если есть) и исключение(если есть)

ну как и в любой другой метод который then*

ну по модулю исключения

помоему вот здесь то что вам нужно
https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/taking-either-of-completion-stages-result.html

не, к сожалению, это такой же anyOf, только тут  с типами по-проще

anyOf возвращает <Object>

тут возник вопрос:

  CompletableFuture<Integer> mustReturn42() {
    CompletableFuture<Integer> fastRequest = CompletableFuture.supplyAsync(
        () -> {
          if (new Random().nextBoolean()) {
            return 42;
          } else {
            return 1;
          }
        });
    CompletableFuture<Integer> slowRequest =
        CompletableFuture.supplyAsync(
            () -> {
              try {
                Thread.sleep(1000);
              } catch (InterruptedException e) {
                throw new RuntimeException(e);
              }
              return 41;
            });
 
    return fastRequest.thenCompose(
        fastResult -> {
          if (fastResult == 42) {
            return CompletableFuture.completedFuture(42);
          } else {
  // this is a data race, right?   
            return slowRequest.thenApply(slowResult -> slowResult + fastResult);
          }
        });
  }

есть ли тут гонка по данным?
в смысле fastResult - это же просто данные, а мы их в thenApply прихаем, который потенциально вообще на другом threadPool исполняется

во, это эквивалент вот такой записи:

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 42);
int my = 123;
future.thenApply(it -> it + my);

вроде тут есть гонка же, да?