"Double" 与 CompletableFuture 的组合

Question

我试图在将 2 个独立的 BiFunction 与 returns 第三个 BiFunction 组合时避免嵌套 CompletableFuture。目前，使用 thenCombine() 不会削减它：

// What I have
public CompletableFuture<CompletableFuture<C>> doStuff() {
    CompletableFuture<A> aFuture = makeSomeA();
    CompletableFuture<B> bFuture = makeSomeB();
    CompletableFuture<CompletableFuture<C>> cFuture = aFuture.thenCombine(bFuture, this::makeSomeC);
    return cFuture;
}

// What I want
public CompletableFuture<C> doStuff() {
    CompletableFuture<A> aFuture = makeSomeA();
    CompletableFuture<B> bFuture = makeSomeB();
    // obv this method does not exist
    CompletableFuture<C> c = aFuture.thenBicompose(bFuture, this::makeSomeC);
} 

private CompletableFuture<A> makeSomeA() {...}
private CompletableFuture<B> makeSomeB() {...}
private CompletableFuture<C> makeSomeC(A a, B b) {...}

如果有 CompletableFuture monad，我基本上是想找到一种看起来像 haskell 的方法：

doStuff :: CompletableFuture C
doStuff = do
    a <- makeSomeA
    b <- makeSomeB
    makeSomeC a b

makeSomeA :: CompletableFuture A
makeSomeB :: CompletableFuture B
makeSomeC :: A -> B -> CompletableFuture C

我在某处读到 join() 是 Completable future 的 flatMap，所以我想我可以使用这种方法来做类似 aFuture.thenCombine(bFuture, ((Function<CompletableFuture<C>,C>) CompletableFuture::join).compose(this::makeSomeC) 的事情，但我不确定这是不是proper/advised 方法。而且我不能说这对可读性有任何帮助...

Answer 1

我想最简单的解决方案就是在之后应用 thenCompose(identity()):

public CompletableFuture<C> doStuff() {
    CompletableFuture<A> aFuture = makeSomeA();
    CompletableFuture<B> bFuture = makeSomeB();
    CompletableFuture<CompletableFuture<C>> cFuture = aFuture.thenCombine(bFuture, this::makeSomeC);
    return cFuture.thenCompose(Function.identity());
}

或者，引入一个简单的 Pair class 来合并 A 和 B 的结果并使用 thenCompose():

public CompletableFuture<C> doStuff() {
    CompletableFuture<A> aFuture = makeSomeA();
    CompletableFuture<B> bFuture = makeSomeB();
    CompletableFuture<Pair<A, B>> cFuture = aFuture.thenCombine(bFuture, Pair::new);
    return cFuture.thenCompose(p -> makeSomeC(p.a, p.b));
}

private static class Pair<A, B> {
    A a;
    B b;

    public Pair(A a, B b) {
        this.a = a;
        this.b = b;
    }
}

还有第三个没有Pair的选择：

public CompletableFuture<C> doStuff() {
    CompletableFuture<A> aFuture = makeSomeA();
    CompletableFuture<B> bFuture = makeSomeB();
    CompletableFuture<Void> cFuture = CompletableFuture.allOf(aFuture, bFuture);
    return cFuture.thenCompose(__ -> makeSomeC(aFuture.join(), bFuture.join()));
}

Answer 2

对我来说，thenCompose 直接等同于 Haskell Monad.bind。

thenCompose 可以像 Haskell monad bind 一样嵌套，这也是 do-expression in Haskell 的结果。使用它你的问题可以这样解决：

public CompletableFuture<C> doStuff() {
    CompletableFuture<A> aFuture = makeSomeA();
    CompletableFuture<B> bFuture = makeSomeB();
    return aFuture.thenCompose(a -> bFuture.thenCompose(b -> makeSomeC(a, b)));
}

类型说明

这可以通过检查函数的类型看出。

Monad bind -- 在 Haskell 中写成 >>= -- 具有以下类型：

(>>=) :: Monad m => m a -> (a -> m b) -> m b

thenCompose in Java 具有以下签名：

public <U> CompletionStage<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn)

以上转换为 Haskell 语法，带有一个额外参数作为显式 this，如下所示：

thenCompose :: CompletionStage T -> (T -> CompletionStage U) -> CompletionStage U

我们可以看到这个和Haskell类型的结构是一样的。不同之处在于名称，Haskell 对 higher-kinded 的支持并不完全由 Java 接口表达。

注意问题中的 Haskell 代码

但是我对你的 Haskell 代码有点不解。在我看来，您的 Haskell 代码正在执行以下操作：

public CompletableFuture<C> doStuff() {
    return makeSomeA().thenCompose(a -> makeSomeB().thenCompose(b -> makeSomeC(a, b)));
}

也就是说，等到 makeSomeA 操作完成后才开始 makeSomeB。另一方面，Java 代码并行启动两个操作，然后在开始 C 之前等待结果。但也许这是一种懒惰的事情。

"Double" 与 CompletableFuture 的组合

"Double" composition with CompletableFuture

java

haskell

java-8

completable-future

类型说明

注意问题中的 Haskell 代码