CompletableFutures (cyclops-react 2.0.0-MI1 API)

java.lang.Object
- cyclops.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 class CompletableFutures.Instances
Companion class for creating Type Class instances for working with CompletableFutures

Nested Classes
Modifier and Type	Class and Description
`static class`	`CompletableFutures.Instances` Companion class for creating Type Class instances for working with CompletableFutures

Constructor Summary

Constructors
Constructor and Description

CompletableFutures()

Constructors
Constructor and Description
`CompletableFutures()`

Method Summary

All Methods Static Methods Concrete Methods
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 single 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 <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 <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> java.util.concurrent.CompletableFuture<T>`	`narrow(java.util.concurrent.CompletableFuture<? extends T> f)` Narrow covariant type parameter
`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 FutureWs to a Future with a Stream
`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

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 FutureWs 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<PSetX<Integer>> futures = CompletableFutures.accumulateSuccess(ListX.of(just,none,CompletableFuture.completedFuture(1)),Reducers.toPSetX());
       
       //CompletableFuture[PSetX[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 single 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<PSetX<Integer>> futures = CompletableFutures.accumulateSuccess(ListX.of(just,none,CompletableFuture.completedFuture(1)),Reducers.toPSetX());
       
       //CompletableFuture[PSetX[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 single 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 single 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

Class CompletableFutures

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CompletableFutures

Method Detail

forEach4

forEach3

forEach2

sequence

sequence

accumulateSuccess

accumulateSuccess

accumulateSuccess

accumulate

accumulate

accumulate

schedule

schedule

combine

combine

zip

zip

narrow