code: public <A, B, ERR, RESULT> OrFuture<RESULT, Every<ERR>>
    withGood(OrFuture<? extends A, ? extends Every<? extends ERR>> fa,
             OrFuture<? extends B, ? extends Every<? extends ERR>> fb,
             BiFunction<? super A, ? super B, ? extends RESULT> function) {
  
      return withPromise(this, promise ->
        fa.onComplete(ora ->
            fb.onComplete(orb ->
                promise.complete(Accumulation.withGood(ora, orb, function)))));
    }
docs: Combines two accumulating OrFutures into a single one using the given function.
  The resulting OrFuture will complete with a Good if both OrFutures complete with
  Goods, otherwise it will complete with a Bad containing every error in the Bads.
  
  @param <A>      the success type
  @param <B>      the success type
  @param <ERR>    the error type of the OrFutures
  @param <RESULT> the success type of the resulting OrFuture
  @param fa       the first OrFuture to combine
  @param fb       the second OrFuture to combine
  @param function the function combining the OrFutures
  @return an OrFuture that completes with a Good if both OrFutures completed with
  Goods, otherwise completes with a Bad containing every error.