具有CompletableFuture的"双重"组合

Question

当我CompletableFuture将两个独立的组合与一个BiFunction返回第三个独立的组合时,我试图避免嵌套.目前,使用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) {...}

我基本上试图找到一种看起来像haskell的方式,如果有一个CompletableFuturemonad:

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

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

我读到的地方是join()可完成flatMap的未来,所以我想我可以使用这种方法来做类似的事情,aFuture.thenCombine(bFuture, ((Function<CompletableFuture<C>,C>) CompletableFuture::join).compose(this::makeSomeC)但我不确定这是正确/建议的方式.而且我不能说这有助于以任何方式提供可读性......

Answer 1

对我而言,它看起来就像thenCompose是Haskell的直接等价物Monad.bind.

thenCompose可以用与Haskell monad绑定相同的方式嵌套,这也是Haskell中do-expression的结果.使用它可以解决您的问题,如下所示:

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

类型说明

通过检查函数的类型可以看出这一点.

Monad绑定 - 用>>=Haskell 编写- 具有以下类型:

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

thenCompose 在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对更高级别的支持的事实并不完全由Java接口表达.

请注意问题中的Haskell代码

但我对你的Haskell代码感到有点困惑.对我来说,看起来你的Haskell代码正在执行以下操作:

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

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

Answer 2

我想最简单的解决方案就是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类来组合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()));
}