cyclops.companion

Class CompletableFutures

java.lang.Object

cyclops.companion.CompletableFutures

public class CompletableFutures
extends java.lang.Object

Utilty methods for working with JDK CompletableFutures

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	CompletableFutures.CompletableFutureKind<T> Simulates Higher Kinded Types for CompletableFuture's CompletableFutureKind is a CompletableFuture and a Higher Kinded Type (Witness.completableFuture,T)
static class	CompletableFutures.Instances Companion class for creating Type Class instances for working with CompletableFutures

Constructor Summary

Constructors

Constructor and Description
CompletableFutures()

Method Summary

Modifier and Type	Method and Description
static <T,R> java.util.concurrent.CompletableFuture<R>	accumulate(CollectionX<java.util.concurrent.CompletableFuture<T>> fts, java.util.function.Function<? super T,R> mapper, Monoid<R> reducer) Asynchronously accumulate the results of a batch of Futures which using the supplied mapping function to convert the data from each Future before reducing them using the supplied supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids .
static <T,R> java.util.concurrent.CompletableFuture<R>	accumulate(CollectionX<java.util.concurrent.CompletableFuture<T>> fts, Reducer<R> reducer) Asynchronously accumulate the results of Futures, a singleUnsafe failure will cause a failed result, using the supplied Reducer cyclops2.Reducers
static <T> java.util.concurrent.CompletableFuture<T>	accumulate(Monoid<T> reducer, CollectionX<java.util.concurrent.CompletableFuture<T>> fts) Asynchronously accumulate the results only from the provided Futures, reducing them using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids .
static <T,R> java.util.concurrent.CompletableFuture<R>	accumulateSuccess(CollectionX<java.util.concurrent.CompletableFuture<T>> fts, java.util.function.Function<? super T,R> mapper, Monoid<R> reducer) Asynchronously accumulate the results only from those Futures which have completed successfully, using the supplied mapping function to convert the data from each Future before reducing them using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids .
static <T,R> java.util.concurrent.CompletableFuture<R>	accumulateSuccess(CollectionX<java.util.concurrent.CompletableFuture<T>> fts, Reducer<R> reducer) Asynchronously accumulate the results only from those Futures which have completed successfully.
static <T,R> java.util.concurrent.CompletableFuture<T>	accumulateSuccess(Monoid<T> reducer, CollectionX<java.util.concurrent.CompletableFuture<T>> fts) Asynchronously accumulate the results only from those Futures which have completed successfully, reducing them using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids
static <T> Active<Witness.completableFuture,T>	allTypeclasses(java.util.concurrent.CompletableFuture<T> f)
static <T1,T2,R> java.util.concurrent.CompletableFuture<R>	combine(java.util.concurrent.CompletableFuture<? extends T1> f, java.util.concurrent.CompletableFuture<? extends T2> v, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Combine a CompletableFuture with the provided CompletableFuture asynchronously (if not completed) using the supplied BiFunction
static <T1,T2,R> java.util.concurrent.CompletableFuture<R>	combine(java.util.concurrent.CompletableFuture<? extends T1> f, Value<? extends T2> v, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Combine a CompletableFuture with the provided Value asynchronously (if not completed) using the supplied BiFunction
static <W1,T> Coproduct<W1,Witness.completableFuture,T>	coproduct(java.util.concurrent.CompletableFuture<T> f, InstanceDefinitions<W1> def2)
static <T,R1,R> java.util.concurrent.CompletableFuture<R>	forEach2(java.util.concurrent.CompletableFuture<? extends T> value1, java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<R1>> value2, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) Perform a For Comprehension over a CompletableFuture, accepting a generating function.
static <T1,T2,R1,R2,R> java.util.concurrent.CompletableFuture<R>	forEach3(java.util.concurrent.CompletableFuture<? extends T1> value1, java.util.function.Function<? super T1,? extends java.util.concurrent.CompletableFuture<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends java.util.concurrent.CompletableFuture<R2>> value3, Fn3<? super T1,? super R1,? super R2,? extends R> yieldingFunction) Perform a For Comprehension over a CompletableFuture, accepting 2 generating function.
static <T1,T2,T3,R1,R2,R3,R> java.util.concurrent.CompletableFuture<R>	forEach4(java.util.concurrent.CompletableFuture<? extends T1> value1, java.util.function.Function<? super T1,? extends java.util.concurrent.CompletableFuture<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends java.util.concurrent.CompletableFuture<R2>> value3, Fn3<? super T1,? super R1,? super R2,? extends java.util.concurrent.CompletableFuture<R3>> value4, Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a For Comprehension over a CompletableFuture, accepting 3 generating function.
static <T> Cokleisli<Witness.completableFuture,T,java.util.concurrent.CompletableFuture<T>>	kindCokleisli()
static <T> Kleisli<Witness.completableFuture,java.util.concurrent.CompletableFuture<T>,T>	kindKleisli()
static <T,W extends WitnessType<W>> CompletableFutureT<W,T>	liftM(java.util.concurrent.CompletableFuture<T> opt, W witness)
<W2,T,R> Nested<Witness.completableFuture,W2,R>	mapM(java.util.concurrent.CompletableFuture<T> f, java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs)
static <T> java.util.concurrent.CompletableFuture<T>	narrow(java.util.concurrent.CompletableFuture<? extends T> f) Narrow covariant type parameter
static <W1,T> Nested<Witness.completableFuture,W1,T>	nested(java.util.concurrent.CompletableFuture<Higher<W1,T>> nested, InstanceDefinitions<W1> def2)
static <T> java.util.concurrent.CompletableFuture<T>	ofResult(T value)
<W1,T> Product<Witness.completableFuture,W1,T>	product(java.util.concurrent.CompletableFuture<T> f, Active<W1,T> active)
static <T> java.util.concurrent.CompletableFuture<T>	schedule(long delay, java.util.concurrent.ScheduledExecutorService ex, java.util.function.Supplier<T> t) Schedule the population of a CompletableFuture from the provided Supplier after the specified delay.
static <T> java.util.concurrent.CompletableFuture<T>	schedule(java.lang.String cron, java.util.concurrent.ScheduledExecutorService ex, java.util.function.Supplier<T> t) Schedule the population of a CompletableFuture from the provided Supplier, the provided Cron (Quartz format) expression will be used to trigger the population of the CompletableFuture.
static <T> java.util.concurrent.CompletableFuture<ListX<T>>	sequence(CollectionX<java.util.concurrent.CompletableFuture<T>> fts) Asynchronous sequence operation that convert a Collection of Futures to a Future with a List
static <T> java.util.concurrent.CompletableFuture<ReactiveSeq<T>>	sequence(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> fts) Asynchronous sequence operation that convert a Stream of Futures to a Future with a Stream
static <T,R> java.util.concurrent.CompletableFuture<R>	tailRec(T initial, java.util.function.Function<? super T,? extends java.util.concurrent.CompletableFuture<? extends Xor<T,R>>> fn)
static <T> Higher<Witness.completableFuture,T>	widen(java.util.concurrent.CompletableFuture<T> narrow)
static <T1,T2,R> java.util.concurrent.CompletableFuture<R>	zip(java.util.concurrent.CompletableFuture<? extends T1> f, java.lang.Iterable<? extends T2> v, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Combine an CompletableFuture with the provided Iterable (selecting one element if present) using the supplied BiFunction
static <T1,T2,R> java.util.concurrent.CompletableFuture<R>	zip(org.reactivestreams.Publisher<? extends T2> p, java.util.concurrent.CompletableFuture<? extends T1> f, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Combine an CompletableFuture with the provided Publisher (selecting one element if present) using the supplied BiFunction

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

CompletableFutures

public CompletableFutures()

Method Detail

tailRec

public static <T,R> java.util.concurrent.CompletableFuture<R> tailRec(T initial,
                                                                      java.util.function.Function<? super T,? extends java.util.concurrent.CompletableFuture<? extends Xor<T,R>>> fn)

kindKleisli

public static <T> Kleisli<Witness.completableFuture,java.util.concurrent.CompletableFuture<T>,T> kindKleisli()

widen

public static <T> Higher<Witness.completableFuture,T> widen(java.util.concurrent.CompletableFuture<T> narrow)

kindCokleisli

public static <T> Cokleisli<Witness.completableFuture,T,java.util.concurrent.CompletableFuture<T>> kindCokleisli()

ofResult

public static <T> java.util.concurrent.CompletableFuture<T> ofResult(T value)

nested

public static <W1,T> Nested<Witness.completableFuture,W1,T> nested(java.util.concurrent.CompletableFuture<Higher<W1,T>> nested,
                                                                   InstanceDefinitions<W1> def2)

product

public <W1,T> Product<Witness.completableFuture,W1,T> product(java.util.concurrent.CompletableFuture<T> f,
                                                              Active<W1,T> active)

coproduct

public static <W1,T> Coproduct<W1,Witness.completableFuture,T> coproduct(java.util.concurrent.CompletableFuture<T> f,
                                                                         InstanceDefinitions<W1> def2)

allTypeclasses

public static <T> Active<Witness.completableFuture,T> allTypeclasses(java.util.concurrent.CompletableFuture<T> f)

mapM

public <W2,T,R> Nested<Witness.completableFuture,W2,R> mapM(java.util.concurrent.CompletableFuture<T> f,
                                                            java.util.function.Function<? super T,? extends Higher<W2,R>> fn,
                                                            InstanceDefinitions<W2> defs)

liftM

public static <T,W extends WitnessType<W>> CompletableFutureT<W,T> liftM(java.util.concurrent.CompletableFuture<T> opt,
                                                                         W witness)

forEach4

public static <T1,T2,T3,R1,R2,R3,R> java.util.concurrent.CompletableFuture<R> forEach4(java.util.concurrent.CompletableFuture<? extends T1> value1,
                                                                                       java.util.function.Function<? super T1,? extends java.util.concurrent.CompletableFuture<R1>> value2,
                                                                                       java.util.function.BiFunction<? super T1,? super R1,? extends java.util.concurrent.CompletableFuture<R2>> value3,
                                                                                       Fn3<? super T1,? super R1,? super R2,? extends java.util.concurrent.CompletableFuture<R3>> value4,
                                                                                       Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Perform a For Comprehension over a CompletableFuture, accepting 3 generating function. This results in a four level nested internal iteration over the provided CompletableFutures.

 

   import static com.aol.cyclops2.reactor.CompletableFutures.forEach4;

    forEach4(CompletableFuture.just(1),
    a-> CompletableFuture.just(a+1),
    (a,b) -> CompletableFuture.<Integer>just(a+b),
    a                  (a,b,c) -> CompletableFuture.<Integer>just(a+b+c),
    Tuple::tuple)

 
 

Parameters:

value1 - top level CompletableFuture

value2 - Nested CompletableFuture

value3 - Nested CompletableFuture

value4 - Nested CompletableFuture

yieldingFunction - Generates a result per combination

Returns:

CompletableFuture with a combined value generated by the yielding function

forEach3

public static <T1,T2,R1,R2,R> java.util.concurrent.CompletableFuture<R> forEach3(java.util.concurrent.CompletableFuture<? extends T1> value1,
                                                                                 java.util.function.Function<? super T1,? extends java.util.concurrent.CompletableFuture<R1>> value2,
                                                                                 java.util.function.BiFunction<? super T1,? super R1,? extends java.util.concurrent.CompletableFuture<R2>> value3,
                                                                                 Fn3<? super T1,? super R1,? super R2,? extends R> yieldingFunction)

Perform a For Comprehension over a CompletableFuture, accepting 2 generating function. This results in a three level nested internal iteration over the provided CompletableFutures.

 

   import static com.aol.cyclops2.reactor.CompletableFutures.forEach3;

    forEach3(CompletableFuture.just(1),
    a-> CompletableFuture.just(a+1),
    (a,b) -> CompletableFuture.<Integer>just(a+b),
    Tuple::tuple)

 
 

Parameters:

value1 - top level CompletableFuture

value2 - Nested CompletableFuture

value3 - Nested CompletableFuture

yieldingFunction - Generates a result per combination

Returns:

CompletableFuture with a combined value generated by the yielding function

forEach2

public static <T,R1,R> java.util.concurrent.CompletableFuture<R> forEach2(java.util.concurrent.CompletableFuture<? extends T> value1,
                                                                          java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<R1>> value2,
                                                                          java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

Perform a For Comprehension over a CompletableFuture, accepting a generating function. This results in a two level nested internal iteration over the provided CompletableFutures.

 

   import static com.aol.cyclops2.reactor.CompletableFutures.forEach;

    forEach(CompletableFuture.just(1),
    a-> CompletableFuture.just(a+1),
    Tuple::tuple)

 
 

Parameters:

value1 - top level CompletableFuture

value2 - Nested CompletableFuture

yieldingFunction - Generates a result per combination

Returns:

CompletableFuture with a combined value generated by the yielding function

sequence

public static <T> java.util.concurrent.CompletableFuture<ListX<T>> sequence(CollectionX<java.util.concurrent.CompletableFuture<T>> fts)

Asynchronous sequence operation that convert a Collection of Futures to a Future with a List

  
   CompletableFuture<ListX<Integer>> futures =CompletableFuture.sequence(ListX.of(
                                                          CompletableFuture.completedFuture(10),
                                                          CompletableFuture.completedFuture(1)));
         //ListX.of(10,1)
 
 
 

Parameters:

fts - Collection of Futures to Sequence into a Future with a List

Returns:

Future with a List

sequence

public static <T> java.util.concurrent.CompletableFuture<ReactiveSeq<T>> sequence(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> fts)

Asynchronous sequence operation that convert a Stream of Futures to a Future with a Stream

  
   CompletableFuture<ListX<Integer>> futures =CompletableFuture.sequence(ListX.of(
                                                          CompletableFuture.completedFuture(10),
                                                          CompletableFuture.completedFuture(1)));
         //ListX.of(10,1)
 
 
 

Parameters:

fts - Stream of Futures to Sequence into a Future with a Stream

Returns:

Future with a Stream

accumulateSuccess

public static <T,R> java.util.concurrent.CompletableFuture<R> accumulateSuccess(CollectionX<java.util.concurrent.CompletableFuture<T>> fts,
                                                                                Reducer<R> reducer)

Asynchronously accumulate the results only from those Futures which have completed successfully. Also @see accumulate(CollectionX, Reducer) if you would like a failure to result in a CompletableFuture with an error

  
 
 CompletableFuture<Integer> just = CompletableFuture.completedFuture(10);
      CompletableFuture<Integer> none = Future.ofError(new NoSuchElementException())
                                               .getFuture();
       
 CompletableFuture<PersistentSetX<Integer>> futures = CompletableFutures.accumulateSuccess(ListX.of(just,none,CompletableFuture.completedFuture(1)),Reducers.toPersistentSetX());
       
       //CompletableFuture[PersistentSetX[10,1]]
  
  

Parameters:

fts - Collection of Futures to accumulate successes

reducer - Reducer to accumulate results

Returns:

CompletableFuture asynchronously populated with the accumulate success operation

accumulateSuccess

public static <T,R> java.util.concurrent.CompletableFuture<R> accumulateSuccess(CollectionX<java.util.concurrent.CompletableFuture<T>> fts,
                                                                                java.util.function.Function<? super T,R> mapper,
                                                                                Monoid<R> reducer)

Asynchronously accumulate the results only from those Futures which have completed successfully, using the supplied mapping function to convert the data from each Future before reducing them using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids .

  
 CompletableFuture<String> future = CompletableFutures.accumulate(ListX.of(CompletableFuture.completedFuture(10),CompletableFuture.completedFuture(1)),i->""+i,Monoids.stringConcat);
        //CompletableFuture["101"]
 
 

Parameters:

fts - Collection of Futures to accumulate successes

mapper - Mapping function to be applied to the result of each Future

reducer - Monoid to combine values from each Future

Returns:

CompletableFuture asynchronously populated with the accumulate operation

accumulateSuccess

public static <T,R> java.util.concurrent.CompletableFuture<T> accumulateSuccess(Monoid<T> reducer,
                                                                                CollectionX<java.util.concurrent.CompletableFuture<T>> fts)

Asynchronously accumulate the results only from those Futures which have completed successfully, reducing them using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids

  
 CompletableFuture<Integer> just =CompletableFuture.completedFuture(10);
 CompletableFuture<Integer> future =CompletableFutures.accumulate(Monoids.intSum, ListX.of(just,CompletableFuture.completedFuture(1)));
       //CompletableFuture[11]
 
 

Parameters:

fts - Collection of Futures to accumulate successes

reducer - Monoid to combine values from each Future

Returns:

CompletableFuture asynchronously populated with the accumulate operation

accumulate

public static <T,R> java.util.concurrent.CompletableFuture<R> accumulate(CollectionX<java.util.concurrent.CompletableFuture<T>> fts,
                                                                         Reducer<R> reducer)

Asynchronously accumulate the results of Futures, a singleUnsafe failure will cause a failed result, using the supplied Reducer cyclops2.Reducers

  
 
 CompletableFuture<Integer> just =CompletableFuture.completedFuture(10);
       CompletableFuture<Integer> none = Future.ofError(new NoSuchElementException()).getFuture();
       
 CompletableFuture<PersistentSetX<Integer>> futures = CompletableFutures.accumulateSuccess(ListX.of(just,none,CompletableFuture.completedFuture(1)),Reducers.toPersistentSetX());
       
       //CompletableFuture[PersistentSetX[10,1]]
  
  

Parameters:

fts - Collection of Futures to accumulate successes

reducer - Reducer to accumulate results

Returns:

Future asynchronously populated with the accumulate success operation

accumulate

public static <T,R> java.util.concurrent.CompletableFuture<R> accumulate(CollectionX<java.util.concurrent.CompletableFuture<T>> fts,
                                                                         java.util.function.Function<? super T,R> mapper,
                                                                         Monoid<R> reducer)

Asynchronously accumulate the results of a batch of Futures which using the supplied mapping function to convert the data from each Future before reducing them using the supplied supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids . A singleUnsafe Failure results in a Failed Future.

  
 CompletableFuture<String> future = Future.accumulate(ListX.of(CompletableFuture.completedFuture(10),CompletableFuture.completedFuture(1)),i->""+i,Monoids.stringConcat);
        //CompletableFuture["101"]
 
 

Parameters:

fts - Collection of Futures to accumulate successes

mapper - Mapping function to be applied to the result of each Future

reducer - Monoid to combine values from each Future

Returns:

CompletableFuture asynchronously populated with the accumulate operation

accumulate

public static <T> java.util.concurrent.CompletableFuture<T> accumulate(Monoid<T> reducer,
                                                                       CollectionX<java.util.concurrent.CompletableFuture<T>> fts)

Asynchronously accumulate the results only from the provided Futures, reducing them using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids . A singleUnsafe Failure results in a Failed Future.

  
 CompletableFuture<Integer> just =CompletableFuture.completedFuture(10);
 
 CompletableFuture<Integer> future =CompletableFutures.accumulate(Monoids.intSum,ListX.of(just,CompletableFuture.completableFuture(1)));
       //CompletableFuture[11]
 
 

Parameters:

fts - Collection of Futures to accumulate successes

reducer - Monoid to combine values from each Future

Returns:

CompletableFuture asynchronously populated with the accumulate operation

schedule

public static <T> java.util.concurrent.CompletableFuture<T> schedule(java.lang.String cron,
                                                                     java.util.concurrent.ScheduledExecutorService ex,
                                                                     java.util.function.Supplier<T> t)

Schedule the population of a CompletableFuture from the provided Supplier, the provided Cron (Quartz format) expression will be used to trigger the population of the CompletableFuture. The provided ScheduledExecutorService provided the thread on which the Supplier will be executed.

  
  
    CompletableFuture<String> future = CompletableFutures.schedule("* * * * * ?", Executors.newScheduledThreadPool(1), ()->"hello");
    
    //CompletableFuture["hello"]
 
 

Parameters:

cron - Cron expression in Quartz format

ex - ScheduledExecutorService used to execute the provided Supplier

t - The Supplier to execute to populate the CompletableFuture

Returns:

CompletableFuture populated on a Cron based Schedule

schedule

public static <T> java.util.concurrent.CompletableFuture<T> schedule(long delay,
                                                                     java.util.concurrent.ScheduledExecutorService ex,
                                                                     java.util.function.Supplier<T> t)

Schedule the population of a CompletableFuture from the provided Supplier after the specified delay. The provided ScheduledExecutorService provided the thread on which the Supplier will be executed.

  
  
    CompletableFuture<String> future = CompletableFutures.schedule(10l, Executors.newScheduledThreadPool(1), ()->"hello");
    
    //CompletableFuture["hello"]
 
 

Parameters:

delay - Delay after which the CompletableFuture should be populated

ex - ScheduledExecutorService used to execute the provided Supplier

t - he Supplier to execute to populate the CompletableFuture

Returns:

CompletableFuture populated after the specified delay

combine

public static <T1,T2,R> java.util.concurrent.CompletableFuture<R> combine(java.util.concurrent.CompletableFuture<? extends T1> f,
                                                                          Value<? extends T2> v,
                                                                          java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Combine a CompletableFuture with the provided Value asynchronously (if not completed) using the supplied BiFunction

  
  CompletableFutures.combine(CompletableFuture.completedFuture(10),Maybe.just(20), this::add)
  //CompletableFuture [30]
  
  private int add(int a, int b) {
            return a + b;
        }
  
 
 

Parameters:

f - CompletableFuture to combine with a value

v - Value to combine with

fn - Combining function

Returns:

CompletableFuture combined with supplied value

combine

public static <T1,T2,R> java.util.concurrent.CompletableFuture<R> combine(java.util.concurrent.CompletableFuture<? extends T1> f,
                                                                          java.util.concurrent.CompletableFuture<? extends T2> v,
                                                                          java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Combine a CompletableFuture with the provided CompletableFuture asynchronously (if not completed) using the supplied BiFunction

  
  CompletableFutures.combine(CompletableFuture.completedFuture(10),CompletableFuture.completedFuture(20), this::add)
  //CompletableFuture [30]
  
  private int add(int a, int b) {
            return a + b;
        }
  
 
 

Parameters:

f - CompletableFuture to combine with a value

v - Value to combine with

fn - Combining function

Returns:

CompletableFuture combined with supplied value

zip

public static <T1,T2,R> java.util.concurrent.CompletableFuture<R> zip(java.util.concurrent.CompletableFuture<? extends T1> f,
                                                                      java.lang.Iterable<? extends T2> v,
                                                                      java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Combine an CompletableFuture with the provided Iterable (selecting one element if present) using the supplied BiFunction

  
  CompletableFutures.zip(CompletableFuture.completedFuture(10),Arrays.asList(20), this::add)
  //CompletableFuture[30]
  
  private int add(int a, int b) {
            return a + b;
        }
  
 
 

Parameters:

f - CompletableFuture to combine with first element in Iterable (if present)

v - Iterable to combine

fn - Combining function

Returns:

CompletableFuture combined with supplied Iterable

zip

public static <T1,T2,R> java.util.concurrent.CompletableFuture<R> zip(org.reactivestreams.Publisher<? extends T2> p,
                                                                      java.util.concurrent.CompletableFuture<? extends T1> f,
                                                                      java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Combine an CompletableFuture with the provided Publisher (selecting one element if present) using the supplied BiFunction

  
  CompletableFutures.zip(Flux.just(10),CompletableFuture.completedResult(10), this::add)
  //CompletableFuture[30]
  
  private int add(int a, int b) {
            return a + b;
        }
  
 
 

Parameters:

p - Publisher to combine

f - CompletableFuture to combine with

fn - Combining function

Returns:

CompletableFuture combined with supplied Publisher

narrow

public static <T> java.util.concurrent.CompletableFuture<T> narrow(java.util.concurrent.CompletableFuture<? extends T> f)

Narrow covariant type parameter

Parameters:

broad - CompletableFuture with covariant type parameter

Returns:

Narrowed Optional