Future (cyclops 10.3.3 API)

java.lang.Object
- cyclops.control.Future<T>

Type Parameters:

T - Type of wrapped future value

All Implemented Interfaces:

Convert<Higher<DataWitness.future,T>>, Higher<DataWitness.future,T>, SealedOr<T>, EmptyUnit<T>, Unit<T>, Filters<T>, To<Future<T>>, ReactiveTransformable<T>, Transformable<T>, MonadicValue<T>, OrElseValue<T,Future<T>>, Completable<T>, Recoverable<T>, RecoverableFrom<java.lang.Throwable,T>, Value<T>, Zippable<T>, io.kindedj.Hk<DataWitness.future,T>, java.lang.Iterable<T>, org.reactivestreams.Publisher<T>
```
public class Future<T>
extends java.lang.Object
implements To<Future<T>>, MonadicValue<T>, Completable<T>, Higher<DataWitness.future,T>, RecoverableFrom<java.lang.Throwable,T>, Zippable<T>, ReactiveTransformable<T>, OrElseValue<T,Future<T>>
```
A Wrapper around CompletableFuture that implements cyclops interfaces and provides a more standard api e.g. transform instead of thenApply flatMap instead of thenCompose combine instead of thenCombine (applicative functor ap)

Constructor Summary

Constructors
Constructor and Description

Future()

Constructors
Constructor and Description
`Future()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T,R> Future<R>`	`accumulate(java.lang.Iterable<Future<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> Future<R>`	`accumulate(java.lang.Iterable<Future<T>> fts, Reducer<R,T> reducer)` Asynchronously accumulate the results of Futures, a single failure will cause a failed result, using the supplied Reducer `cyclops2.Reducers`
`static <T> Future<T>`	`accumulate(Monoid<T> reducer, java.lang.Iterable<Future<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.
`static <T,R> Future<R>`	`accumulateSuccess(java.lang.Iterable<Future<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> Future<R>`	`accumulateSuccess(java.lang.Iterable<Future<T>> fts, Reducer<R,T> reducer)` Asynchronously accumulate the results only from those Futures which have completed successfully.
`static <T> Future<T>`	`accumulateSuccess(Monoid<T> reducer, java.lang.Iterable<Future<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> Future<T>`	`allOf(Future<T>... fts)` Wait until all the provided Future's to complete
`static <T> Future<T>`	`anyOf(Future<T>... fts)` Select the first Future to complete
`static <T> Future<T>`	`async(java.util.concurrent.Executor ex, java.util.function.Supplier<T> s)`
`void`	`cancel()` If not already completed, completes this Future with a `CancellationException` Passes true to @see java.util.concurrent.CompletableFuture#cancel as mayInterruptIfRunning parameter on that method has no effect for the default CompletableFuture implementation
`boolean`	`complete(T value)` If not already completed, sets the value of this Future to the provided value
`boolean`	`completeExceptionally(java.lang.Throwable e)` Complete this Future with an Exception
`<R> Future<R>`	`concatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)` A flattening transformation operation that takes the first value from the returned Iterable.
`static <T> Future<T>`	`empty()` An zero Future
`<T1> Future<T1>`	`emptyUnit()`
`Maybe<T>`	`filter(java.util.function.Predicate<? super T> fn)` Keep only elements for which the supplied predicates hold e.g.
`Maybe<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`static <T> Future<T>`	`firstSuccess(Future<T>... fts)` Select the first Future to return with a successful result
`<R> Future<R>`	`flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends R>> mapper)` A flattening transformation operation (@see `Optional.flatMap(Function)`
`<R> Future<R>`	`flatMapCf(java.util.function.Function<? super T,? extends java.util.concurrent.CompletionStage<? extends R>> mapper)` A flatMap operation that accepts a CompleteableFuture CompletionStage as the return type
`static <R> Future<R>`	`flatten(Future<? extends Future<R>> nested)`
`<R> R`	`fold(java.util.function.Function<? super T,? extends R> success, java.util.function.Function<? super java.lang.Throwable,? extends R> failure)` Blocking analogue to visitAsync.
`<R> R`	`fold(java.util.function.Function<? super T,? extends R> success, java.util.function.Supplier<? extends R> failure)`
`<R> Future<R>`	`foldAsync(java.util.function.Function<? super T,? extends R> success, java.util.function.Function<? super java.lang.Throwable,? extends R> failure)`
`void`	`forEach(java.util.function.Consumer<? super T> c)`
`void`	`forEach(java.util.function.Consumer<? super T> onNext, java.util.function.Consumer<java.lang.Throwable> onError)`
`void`	`forEach(java.util.function.Consumer<? super T> onNext, java.util.function.Consumer<java.lang.Throwable> onError, java.lang.Runnable onComplete)`
`<R1,R> Future<R>`	`forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)` Perform a two level nested internal iteration over this MonadicValue and the supplied MonadicValue
`<R1,R> Future<R>`	`forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)` Perform a two level nested internal iteration over this MonadicValue and the supplied stream
`<T2,R1,R2,R> Future<R>`	`forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction)` Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
`<T2,R1,R2,R> Future<R>`	`forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Function3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction)` Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
`<T2,R1,R2,R3,R> Future<R>`	`forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Function3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)` Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues
`<T2,R1,R2,R3,R> Future<R>`	`forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Function3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, Function4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)` Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues `Maybe.of(3) .forEach4(a->Maybe.just(a+10), (a,b)->Maybe.just(a+b), (a,b,c)->Maybe.none(), (a,b,c,d)->a+b+c<100, (a,b,c,d)->a+b+c+d); //Maybe.none`
`static <T> Future<T>`	`fromIterable(java.lang.Iterable<T> iterable)` Construct a Future syncrhonously that contains a single value extracted from the supplied Iterable
`static <T> Future<T>`	`fromIterable(java.lang.Iterable<T> iterable, java.util.concurrent.Executor ex)` Construct a Future asyncrhonously that contains a single value extracted from the supplied Iterable
`static <T> Future<T>`	`fromPublisher(org.reactivestreams.Publisher<? extends T> pub)` Construct a Future syncrhonously that contains a single value extracted from the supplied reactive-streams Publisher
`static <T> Future<T>`	`fromPublisher(org.reactivestreams.Publisher<T> pub, java.util.concurrent.Executor ex)` Construct a Future asynchronously that contains a single value extracted from the supplied reactive-streams Publisher
`static <T,X extends java.lang.Throwable> Future<T>`	`fromTry(Try<T,X> value)` Construct a Future syncrhonously from the Supplied Try
`static <T> Future<T>`	`future()` An zero Future
`Try<T,java.lang.Throwable>`	`get()`
`java.util.concurrent.CompletableFuture<T>`	`getFuture()`
`T`	`getOrElse(T alt)`
`boolean`	`isCancelled()`
`boolean`	`isDone()`
`boolean`	`isFailed()`
`boolean`	`isPresent()`
`boolean`	`isSuccess()`
`<R> Future<R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> Future<R>`	`map(java.util.function.Function<? super T,? extends R> fn, java.util.concurrent.Executor ex)` Asyncrhonous transform operation
`<R> Future<R>`	`map(java.util.function.Function<? super T,R> success, java.util.function.Function<java.lang.Throwable,R> failure)` Map this Future differently depending on whether the previous stage completed successfully or failed
`<R> Future<R>`	`mergeMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)` A flattening transformation operation that takes the first value from the returned Publisher.
`java.lang.String`	`mkString()` Returns the class name and the name of the subclass, if there is any value, the value is showed between square brackets.
`static <T> Future<T>`	`narrow(Future<? extends T> of)`
`static <T> Future<T>`	`narrowK(Higher<DataWitness.future,T> future)` Convert the raw Higher Kinded Type for FutureType types into the FutureType type definition class
`Maybe<T>`	`notNull()` Filter elements retaining only values which are not null
`static <T> Future<T>`	`of(java.util.concurrent.CompletableFuture<T> f)` Create a Future instance from the supplied CompletableFuture
`static <T> Future<T>`	`of(java.util.function.Supplier<T> s)` Create a Future object that asyncrhonously populates using the Common ForkJoinPool from the user provided Supplier
`static <T> Future<T>`	`of(java.util.function.Supplier<T> s, java.util.concurrent.Executor ex)` Create a Future object that asyncrhonously populates using the provided Executor and Supplier
`static <T> Future<T>`	`ofError(java.lang.Throwable error)` Construct a completed-with-error Future from the given Exception
`static <T> Future<T>`	`ofResult(T result)` Construct a successfully completed Future from the given value
`<U> Maybe<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`Future<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Transformable, without transforming it
`Future<T>`	`recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)` Returns a new Future that, when this Future completes exceptionally is executed with this Future exception as the argument to the supplied function.
`Future<T>`	`recover(java.util.function.Supplier<? extends T> fn)`
`static <T> Future<T>`	`schedule(long delay, java.util.concurrent.ScheduledExecutorService ex, java.util.function.Supplier<T> t)` Schedule the population of a Future from the provided Supplier after the specified delay.
`static <T> Future<T>`	`schedule(java.lang.String cron, java.util.concurrent.ScheduledExecutorService ex, java.util.function.Supplier<T> t)` Schedule the population of a Future from the provided Supplier, the provided Cron (Quartz format) expression will be used to trigger the population of the Future.
`static <T> Future<ReactiveSeq<T>>`	`sequence(java.lang.Iterable<? extends Future<T>> fts)` Asynchronous sequence operation that convert a Collection of Futures to a Future with a List
`static <T> Future<ReactiveSeq<T>>`	`sequence(ReactiveSeq<? extends Future<T>> stream)`
`static <T> Future<ReactiveSeq<T>>`	`sequence(java.util.stream.Stream<? extends Future<T>> fts)` Sequence operation that convert a Stream of Futures to a Future with a Stream
`ReactiveSeq<T>`	`stream()`
`void`	`subscribe(org.reactivestreams.Subscriber<? super T> sub)`
`static <T,R> Future<R>`	`tailRec(T initial, java.util.function.Function<? super T,? extends Future<? extends Either<T,R>>> fn)`
`java.util.concurrent.CompletableFuture<T>`	`toCompletableFuture()`
`Either<java.lang.Throwable,T>`	`toEither()`
`Ior<java.lang.Throwable,T>`	`toIor()`
`Maybe<T>`	`toMaybe()`
`java.lang.String`	`toString()`
`static <T,R> Future<ReactiveSeq<R>>`	`traverse(java.util.function.Function<? super T,? extends R> fn, ReactiveSeq<Future<T>> stream)`
`<T> Future<T>`	`unit(T unit)`
`<R> Future<R>`	`visitAsync(java.util.function.Function<? super T,? extends R> success, java.util.function.Function<? super java.lang.Throwable,? extends R> failure)` Deprecated.
`static <T> Higher<DataWitness.future,T>`	`widen(Future<T> narrow)`
`<T2,R> Future<R>`	`zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> app)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`<T2,R> Future<R>`	`zip(java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)` Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
`<U> Future<Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)`
`<S,U> Future<Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)`
`<S,U,R> Future<R>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Function3<? super T,? super S,? super U,? extends R> fn3)`
`<T2,T3,T4> Future<Tuple4<T,T2,T3,T4>>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)`
`<T2,T3,T4,R> Future<R>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Function4<? super T,? super T2,? super T3,? super T4,? extends R> fn)`
`<U> Future<Tuple2<T,U>>`	`zipWithPublisher(org.reactivestreams.Publisher<? extends U> other)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.oath.cyclops.types.foldable.To
to

Methods inherited from interface com.oath.cyclops.types.MonadicValue
arity, attemptMap, mapAsync, mapRetry, mapRetry, mapTry, mapTry

Methods inherited from interface com.oath.cyclops.hkt.Higher
applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.oath.cyclops.hkt.Convert
convert

Methods inherited from interface com.oath.cyclops.types.functor.ReactiveTransformable
retry, retry

Methods inherited from interface com.oath.cyclops.types.OrElseValue
orElseUse, orElseUse

Methods inherited from interface com.oath.cyclops.types.Value
asSupplier, collect, fold, generate, iterate, iterator, nonEmptyList, nonEmptyListGet, orElse, orElseGet, print, print, printErr, printOut, toEither, toLazyEither, toLeft, toOption, toOptional, toRight, toTry, toTry, toTry

- Constructor Detail
  - Future
```
public Future()
```
- Method Detail
  - tailRec
```
public static <T,R> Future<R> tailRec(T initial,
                                      java.util.function.Function<? super T,? extends Future<? extends Either<T,R>>> fn)
```
  - widen
```
public static <T> Higher<DataWitness.future,T> widen(Future<T> narrow)
```
  - subscribe
```
public final void subscribe(org.reactivestreams.Subscriber<? super T> sub)
```
    Specified by:
    
    subscribe in interface Value<T>
    
    Specified by:
    
    subscribe in interface org.reactivestreams.Publisher<T>
  - narrowK
```
public static <T> Future<T> narrowK(Higher<DataWitness.future,T> future)
```
    Convert the raw Higher Kinded Type for FutureType types into the FutureType type definition class
    
    Parameters:
    
    future - HKT encoded list into a FutureType
    
    Returns:
    
    FutureType
  - empty
```
public static <T> Future<T> empty()
```
    An zero Future
    
    Returns:
    
    A Future that wraps a CompletableFuture with a null result
  - future
```
public static <T> Future<T> future()
```
    An zero Future
    
    Returns:
    
    A Future that wraps a CompletableFuture with a null result
  - anyOf
```
public static <T> Future<T> anyOf(Future<T>... fts)
```
    Select the first Future to complete
    
    Parameters:
    
    fts - Futures to race
    
    Returns:
    
    First Future to complete
    
    See Also:
    
    CompletableFuture.anyOf(CompletableFuture...)
  - allOf
```
public static <T> Future<T> allOf(Future<T>... fts)
```
    Wait until all the provided Future's to complete
    
    Parameters:
    
    fts - Futures to wait on
    
    Returns:
    
    Future that completes when all the provided Futures Complete. Empty Future result, or holds an Exception from a provided Future that failed.
    
    See Also:
    
    CompletableFuture.allOf(CompletableFuture...)
  - firstSuccess
```
@SafeVarargs
public static <T> Future<T> firstSuccess(Future<T>... fts)
```
    Select the first Future to return with a successful result
```
 
 Future<Integer> ft = Future.future();
       Future<Integer> result = Future.firstSuccess(Future.of(()->1),ft);

       ft.complete(10);
       result.getValue() //1
 
 
```
    Parameters:
    
    fts - Futures to race
    
    Returns:
    
    First Future to return with a result
  - completeExceptionally
```
public boolean completeExceptionally(java.lang.Throwable e)
```
    Complete this Future with an Exception
    
    Specified by:
    
    completeExceptionally in interface Completable<T>
    
    Parameters:
    
    e - Throwable to complete this Future with
    
    See Also:
    
    CompletableFuture.completeExceptionally(Throwable)
  - fromPublisher
```
public static <T> Future<T> fromPublisher(org.reactivestreams.Publisher<T> pub,
                                          java.util.concurrent.Executor ex)
```
    Construct a Future asynchronously that contains a single value extracted from the supplied reactive-streams Publisher
```
 
   ReactiveSeq<Integer> stream =  ReactiveSeq.of(1,2,3);

        Future<Integer> future = Future.fromPublisher(stream,ex);

        //Future[1]

 
 
```
    Parameters:
    
    pub - Publisher to extract value from
    
    ex - Executor to extract value on
    
    Returns:
    
    Future populated asyncrhonously from Publisher
  - fromIterable
```
public static <T> Future<T> fromIterable(java.lang.Iterable<T> iterable,
                                         java.util.concurrent.Executor ex)
```
    Construct a Future asyncrhonously that contains a single value extracted from the supplied Iterable
```
 
  ReactiveSeq<Integer> stream =  ReactiveSeq.of(1,2,3);

        Future<Integer> future = Future.fromIterable(stream,ex);

        //Future[1]

 
 
```
    Parameters:
    
    iterable - Iterable to generate a Future from
    
    ex - Executor to extract value on
    
    Returns:
    
    Future populated asyncrhonously from Iterable
  - fromPublisher
```
public static <T> Future<T> fromPublisher(org.reactivestreams.Publisher<? extends T> pub)
```
    Construct a Future syncrhonously that contains a single value extracted from the supplied reactive-streams Publisher
```
 
   ReactiveSeq<Integer> stream =  ReactiveSeq.of(1,2,3);

        Future<Integer> future = Future.fromPublisher(stream);

        //Future[1]

 
 
```
    Parameters:
    
    pub - Publisher to extract value from
    
    Returns:
    
    Future populated syncrhonously from Publisher
  - fromIterable
```
public static <T> Future<T> fromIterable(java.lang.Iterable<T> iterable)
```
    Construct a Future syncrhonously that contains a single value extracted from the supplied Iterable
```
 
  ReactiveSeq<Integer> stream =  ReactiveSeq.of(1,2,3);

        Future<Integer> future = Future.fromIterable(stream);

        //Future[1]

 
 
```
    Parameters:
    
    iterable - Iterable to extract value from
    
    Returns:
    
    Future populated syncrhonously from Iterable
  - of
```
public static <T> Future<T> of(java.util.concurrent.CompletableFuture<T> f)
```
    Create a Future instance from the supplied CompletableFuture
    
    Parameters:
    
    f - CompletableFuture to wrap as a Future
    
    Returns:
    
    Future wrapping the supplied CompletableFuture
  - forEach
```
public void forEach(java.util.function.Consumer<? super T> c)
```
    Specified by:
    
    forEach in interface Value<T>
    
    Specified by:
    
    forEach in interface java.lang.Iterable<T>
  - forEach
```
public void forEach(java.util.function.Consumer<? super T> onNext,
                    java.util.function.Consumer<java.lang.Throwable> onError)
```
  - forEach
```
public void forEach(java.util.function.Consumer<? super T> onNext,
                    java.util.function.Consumer<java.lang.Throwable> onError,
                    java.lang.Runnable onComplete)
```
  - fromTry
```
public static <T,X extends java.lang.Throwable> Future<T> fromTry(Try<T,X> value)
```
    Construct a Future syncrhonously from the Supplied Try
    
    Parameters:
    
    value - Try to populate Future from
    
    Returns:
    
    Future populated with lazy the value or error in provided Try
  - schedule
```
public static <T> Future<T> schedule(java.lang.String cron,
                                     java.util.concurrent.ScheduledExecutorService ex,
                                     java.util.function.Supplier<T> t)
```
    Schedule the population of a Future from the provided Supplier, the provided Cron (Quartz format) expression will be used to trigger the population of the Future. The provided ScheduledExecutorService provided the thread on which the Supplier will be executed.
```
 

    Future<String> future = Future.schedule("* * * * * ?", Executors.newScheduledThreadPool(1), ()->"hello");

    //Future["hello"]

 
```
    Parameters:
    
    cron - Cron expression in Quartz format
    
    ex - ScheduledExecutorService used to execute the provided Supplier
    
    t - The Supplier to execute to populate the Future
    
    Returns:
    
    Future populated on a Cron based Schedule
  - schedule
```
public static <T> Future<T> schedule(long delay,
                                     java.util.concurrent.ScheduledExecutorService ex,
                                     java.util.function.Supplier<T> t)
```
    Schedule the population of a Future from the provided Supplier after the specified delay. The provided ScheduledExecutorService provided the thread on which the Supplier will be executed.
```
 

    Future<String> future = Future.schedule(10l, Executors.newScheduledThreadPool(1), ()->"hello");

    //Future["hello"]

 
```
    Parameters:
    
    delay - Delay after which the Future should be populated
    
    ex - ScheduledExecutorService used to execute the provided Supplier
    
    t - he Supplier to execute to populate the Future
    
    Returns:
    
    Future populated after the specified delay
  - sequence
```
public static <T> Future<ReactiveSeq<T>> sequence(java.lang.Iterable<? extends Future<T>> fts)
```
    Asynchronous sequence operation that convert a Collection of Futures to a Future with a List
```
 
   Future<Seq<Integer>> futures =Future.sequence(Seq.of(Future.ofResult(10),Future.ofResult(1)));
         //Seq.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> Future<ReactiveSeq<T>> sequence(java.util.stream.Stream<? extends Future<T>> fts)
```
    Sequence operation that convert a Stream of Futures to a Future with a Stream
```
 
   Future<Integer> just = Future.ofResult(10);
   Future<ReactiveSeq<Integer>> futures =Future.sequence(Stream.of(just,Future.ofResult(1)));
         //Seq.of(10,1)

 
 
```
    Parameters:
    
    fts - Strean of Futures to Sequence into a Future with a Stream
    
    Returns:
    
    Future with a Stream
  - sequence
```
public static <T> Future<ReactiveSeq<T>> sequence(ReactiveSeq<? extends Future<T>> stream)
```
  - traverse
```
public static <T,R> Future<ReactiveSeq<R>> traverse(java.util.function.Function<? super T,? extends R> fn,
                                                    ReactiveSeq<Future<T>> stream)
```
  - accumulateSuccess
```
public static <T,R> Future<R> accumulateSuccess(java.lang.Iterable<Future<T>> fts,
                                                Reducer<R,T> reducer)
```
    Asynchronously accumulate the results only from those Futures which have completed successfully. Also @see accumulate(Iterable, Reducer) if you would like a failure to result in a Future with an error
```
 

 Future<Integer> just =Future.of(CompletableFuture.completedFuture(10));
       Future<Integer> none = Future.ofError(new NoSuchElementException());


 Future<PersistentSetX<Integer>> futures = Future.accumulateSuccess(Seq.of(just,none,Future.ofResult(1)),Reducers.toPersistentSetX());
       //Future[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> Future<R> accumulate(java.lang.Iterable<Future<T>> fts,
                                         Reducer<R,T> reducer)
```
    Asynchronously accumulate the results of Futures, a single failure will cause a failed result, using the supplied Reducer cyclops2.Reducers
```
 

 Future<Integer> just =Future.of(CompletableFuture.completedFuture(10));
       Future<Integer> none = Future.ofError(new NoSuchElementException());
 Future<PersistentSetX<Integer>> futures = Future.accumulateSuccess(Seq.of(just,none,Future.ofResult(1)),Reducers.toPersistentSetX());

       //Future[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
  - accumulateSuccess
```
public static <T,R> Future<R> accumulateSuccess(java.lang.Iterable<Future<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 .
```
 
 Future<String> future = Future.accumulate(Seq.of(Future.ofResult(10),Future.ofResult(1)),i->""+i,Monoids.stringConcat);
        //Future["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:
    
    Future asynchronously populated with the accumulate operation
  - accumulateSuccess
```
public static <T> Future<T> accumulateSuccess(Monoid<T> reducer,
                                              java.lang.Iterable<Future<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 .
```
 
 Future<Integer> just =Future.of(CompletableFuture.completedFuture(10));
 Future<Integer> future =Future.accumulate(Monoids.intSum, Seq.of(just,Future.ofResult(1)));
       //Future[11]
 
 
```
    Parameters:
    
    fts - Collection of Futures to accumulate successes
    
    reducer - Monoid to combine values from each Future
    
    Returns:
    
    Future asynchronously populated with the accumulate operation
  - accumulate
```
public static <T,R> Future<R> accumulate(java.lang.Iterable<Future<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.
```
 
 Future<String> future = Future.accumulate(Seq.of(Future.ofResult(10),Future.ofResult(1)),i->""+i,Monoids.stringConcat);
        //Future["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:
    
    Future asynchronously populated with the accumulate operation
  - accumulate
```
public static <T> Future<T> accumulate(Monoid<T> reducer,
                                       java.lang.Iterable<Future<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.
```
 
 Future<Integer> future =Future.accumulate(Monoids.intSum,Seq.of(just,Future.ofResult(1)));
       //Future[11]
 
 
```
    Parameters:
    
    fts - Collection of Futures to accumulate successes
    
    reducer - Monoid to combine values from each Future
    
    Returns:
    
    Future asynchronously populated with the accumulate operation
  - forEach4
```
public <T2,R1,R2,R3,R> Future<R> forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                          java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                          Function3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                          Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
```
    Description copied from interface: MonadicValue
    Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues
```
 
  Maybe.of(3)
       .forEach4(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->Maybe.none(),
                 (a,b,c,d)->a+b+c+d);


  //Maybe.none
 
 
```
    Specified by:
    
    forEach4 in interface MonadicValue<T>
    
    Parameters:
    
    value1 - Nested MonadicValue to iterate over
    
    value2 - Nested MonadicValue to iterate over
    
    value3 - Nested MonadicValue to iterate over
    
    yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements
    
    Returns:
    
    MonadicValue with elements generated via nested iteration
  - forEach4
```
public <T2,R1,R2,R3,R> Future<R> forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                          java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                          Function3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                          Function4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                          Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
```
    Description copied from interface: MonadicValue
    
    Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues Maybe.of(3) .forEach4(a->Maybe.just(a+10), (a,b)->Maybe.just(a+b), (a,b,c)->Maybe.none(), (a,b,c,d)->a+b+c<100, (a,b,c,d)->a+b+c+d); //Maybe.none
    
    Specified by:
    
    forEach4 in interface MonadicValue<T>
    
    Parameters:
    
    value1 - Nested MonadicValue to iterate over
    
    value2 - Nested MonadicValue to iterate over
    
    value3 - Nested MonadicValue to iterate over
    
    filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function
    
    yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements
    
    Returns:
    
    MonadicValue with elements generated via nested iteration
  - forEach3
```
public <T2,R1,R2,R> Future<R> forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                       java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                       Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
```
    Description copied from interface: MonadicValue
    Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
```
 
  Maybe.of(3)
       .forEach3(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->a+b+c<100,
                 (a,b,c)->a+b+c);


  //Maybe[32]
 
 
```
    Specified by:
    
    forEach3 in interface MonadicValue<T>
    
    Parameters:
    
    value1 - Nested MonadicValue to iterate over
    
    value2 - Nested MonadicValue to iterate over
    
    yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements
    
    Returns:
    
    MonadicValue with elements generated via nested iteration
  - forEach3
```
public <T2,R1,R2,R> Future<R> forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                       java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
                                       Function3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                       Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
```
    Description copied from interface: MonadicValue
    Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
```
 
  Maybe.of(3)
       .forEach3(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->a+b+c<100,
                 (a,b,c)->a+b+c);


  //Maybe[32]
 
 
```
    Specified by:
    
    forEach3 in interface MonadicValue<T>
    
    Parameters:
    
    value1 - Nested MonadicValue to iterate over
    
    value2 - Nested MonadicValue to iterate over
    
    filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function
    
    yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements
    
    Returns:
    
    MonadicValue with elements generated via nested iteration
  - forEach2
```
public <R1,R> Future<R> forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                 java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
```
    Description copied from interface: MonadicValue
    Perform a two level nested internal iteration over this MonadicValue and the supplied MonadicValue
```
 
  Maybe.of(3)
       .forEach2(a->Maybe.none(),
                 (a,b)->a+b);


  //Maybe.none()
 
 
```
    Specified by:
    
    forEach2 in interface MonadicValue<T>
    
    Parameters:
    
    value1 - Nested Monadic Type to iterate over
    
    yieldingFunction - Function with pointers to the current element from both monad types that generates the new elements
    
    Returns:
    
    MonadicValue with elements generated via nested iteration
  - forEach2
```
public <R1,R> Future<R> forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
                                 java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
                                 java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
```
    Description copied from interface: MonadicValue
    Perform a two level nested internal iteration over this MonadicValue and the supplied stream
```
 
  Maybe.of(3)
       .forEach2(a->Maybe.none(),
                 a->b-> a<3 && b>10,
                 (a,b)->a+b);


  //Maybe.none()
 
 
```
    Specified by:
    
    forEach2 in interface MonadicValue<T>
    
    Parameters:
    
    value1 - Nested monadic type to iterate over
    
    filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function
    
    yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
    
    Returns:
    
    MonadicValue with elements generated via nested iteration
  - toMaybe
```
public Maybe<T> toMaybe()
```
    Specified by:
    
    toMaybe in interface Value<T>
  - visitAsync
```
@Deprecated
public <R> Future<R> visitAsync(java.util.function.Function<? super T,? extends R> success,
                                            java.util.function.Function<? super java.lang.Throwable,? extends R> failure)
```
    Deprecated.
    Non-blocking visit on the state of this Future
```
 
 Future.ofResult(10)
              .visitAsync(i->i*2, e->-1);
       //Future[20]

       Future.<Integer>ofError(new RuntimeException())
              .visitAsync(i->i*2, e->-1)
       //Future[-1]

 
 
```
    Parameters:
    
    success - Function to execute if the previous stage completes successfully
    
    failure - Function to execute if this Future fails
    
    Returns:
    
    Future with the eventual result of the executed Function
  - foldAsync
```
public <R> Future<R> foldAsync(java.util.function.Function<? super T,? extends R> success,
                               java.util.function.Function<? super java.lang.Throwable,? extends R> failure)
```
  - fold
```
public <R> R fold(java.util.function.Function<? super T,? extends R> success,
                  java.util.function.Function<? super java.lang.Throwable,? extends R> failure)
```
    Blocking analogue to visitAsync. Visit the state of this Future, block until ready.
```
 
  Future.ofResult(10)
               .visit(i->i*2, e->-1);
        //20

        Future.<Integer>ofError(new RuntimeException())
               .visit(i->i*2, e->-1)
        //[-1]

 
 
```
    Parameters:
    
    success - Function to execute if the previous stage completes successfully
    
    failure - Function to execute if this Future fails
    
    Returns:
    
    Result of the executed Function
  - map
```
public <R> Future<R> map(java.util.function.Function<? super T,? extends R> fn)
```
    Description copied from interface: Transformable
    Transform this functor using the supplied transformation function
```
 


    of(1,2,3).map(i->i*2)

    //[2,4,6]

 
 
```
    Specified by:
    
    map in interface Transformable<T>
    
    Specified by:
    
    map in interface MonadicValue<T>
    
    Parameters:
    
    fn - Transformation function
    
    Returns:
    
    Transformed Transformable
  - map
```
public <R> Future<R> map(java.util.function.Function<? super T,? extends R> fn,
                         java.util.concurrent.Executor ex)
```
    Asyncrhonous transform operation
    
    Parameters:
    
    fn - Transformation function
    
    ex - Executor to execute the transformation asynchronously
    
    Returns:
    
    Mapped Future
    
    See Also:
    
    CompletableFuture.thenApplyAsync(Function, Executor)
  - getOrElse
```
public T getOrElse(T alt)
```
  - get
```
public Try<T,java.lang.Throwable> get()
```
  - isSuccess
```
public boolean isSuccess()
```
    Returns:
    
    true if this Future is both complete, and completed without an Exception
  - isDone
```
public boolean isDone()
```
    Specified by:
    
    isDone in interface Completable<T>
    
    Returns:
    
    true if this Future has completed executing
    
    See Also:
    
    CompletableFuture.isDone()
  - isCancelled
```
public boolean isCancelled()
```
    Returns:
    
    True if this Future has been cancelled
    
    See Also:
    
    CompletableFuture.isCancelled()
  - cancel
```
public void cancel()
```
    If not already completed, completes this Future with a CancellationException Passes true to @see java.util.concurrent.CompletableFuture#cancel as mayInterruptIfRunning parameter on that method has no effect for the default CompletableFuture implementation
  - complete
```
public boolean complete(T value)
```
    If not already completed, sets the value of this Future to the provided value
    
    Specified by:
    
    complete in interface Completable<T>
    
    Parameters:
    
    value - Value to set this Future to
  - isFailed
```
public boolean isFailed()
```
    Specified by:
    
    isFailed in interface Completable<T>
    
    Returns:
    
    true if this Future is complete, but completed with an Exception
  - unit
```
public <T> Future<T> unit(T unit)
```
    Specified by:
    
    unit in interface Unit<T>
    
    Specified by:
    
    unit in interface MonadicValue<T>
  - emptyUnit
```
public <T1> Future<T1> emptyUnit()
```
    Specified by:
    
    emptyUnit in interface EmptyUnit<T>
    
    Specified by:
    
    emptyUnit in interface MonadicValue<T>
    
    Returns:
    
    A new, zero instance of this EmptyUnit type
  - stream
```
public ReactiveSeq<T> stream()
```
    Specified by:
    
    stream in interface Value<T>
  - flatten
```
public static <R> Future<R> flatten(Future<? extends Future<R>> nested)
```
  - flatMap
```
public <R> Future<R> flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends R>> mapper)
```
    Description copied from interface: MonadicValue
    A flattening transformation operation (@see Optional.flatMap(Function)
```
 
   Eval.now(1).map(i->i+2).flatMap(i->Eval.later(()->i*3);
   //Eval[9]

 
```
    Specified by:
    
    flatMap in interface MonadicValue<T>
    
    Parameters:
    
    mapper - transformation function
    
    Returns:
    
    MonadicValue
  - flatMapCf
```
public <R> Future<R> flatMapCf(java.util.function.Function<? super T,? extends java.util.concurrent.CompletionStage<? extends R>> mapper)
```
    A flatMap operation that accepts a CompleteableFuture CompletionStage as the return type
    
    Parameters:
    
    mapper - Mapping function
    
    Returns:
    
    FlatMapped Future
  - toEither
```
public Either<java.lang.Throwable,T> toEither()
```
  - toIor
```
public Ior<java.lang.Throwable,T> toIor()
```
  - toCompletableFuture
```
public java.util.concurrent.CompletableFuture<T> toCompletableFuture()
```
  - recover
```
public Future<T> recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)
```
    Returns a new Future that, when this Future completes exceptionally is executed with this Future exception as the argument to the supplied function. Otherwise, if this Future completes normally, applyHKT the returned Future also completes normally with the same value.
```
 
     Future.ofError(new RuntimeException())
            .recover(__ -> true)

    //Future[true]

 
 
```
    Specified by:
    
    recover in interface RecoverableFrom<java.lang.Throwable,T>
    
    Parameters:
    
    fn - the function to use to compute the value of the returned Future if this Future completed exceptionally
    
    Returns:
    
    the new Future
  - recover
```
public Future<T> recover(java.util.function.Supplier<? extends T> fn)
```
    Specified by:
    
    recover in interface Recoverable<T>
  - map
```
public <R> Future<R> map(java.util.function.Function<? super T,R> success,
                         java.util.function.Function<java.lang.Throwable,R> failure)
```
    Map this Future differently depending on whether the previous stage completed successfully or failed
```
 
  Future.ofResult(1)
         .map(i->i*2,e->-1);
 //Future[2]

 
```
    Parameters:
    
    success - Mapping function for successful outcomes
    
    failure - Mapping function for failed outcomes
    
    Returns:
    
    New Future mapped to a new state
  - peek
```
public Future<T> peek(java.util.function.Consumer<? super T> c)
```
    Description copied from interface: Transformable
    Peek at the current value of this Transformable, without transforming it
```
 


    of(1,2,3).map(System.out::println)

    1
    2
    3

 
 
```
    Specified by:
    
    peek in interface Transformable<T>
    
    Parameters:
    
    c - Consumer that recieves each element from this Transformable
    
    Returns:
    
    Transformable that will peek at each value
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - ofResult
```
public static <T> Future<T> ofResult(T result)
```
    Construct a successfully completed Future from the given value
    
    Parameters:
    
    result - To wrap inside a Future
    
    Returns:
    
    Future containing supplied result
  - ofError
```
public static <T> Future<T> ofError(java.lang.Throwable error)
```
    Construct a completed-with-error Future from the given Exception
    
    Parameters:
    
    error - To wrap inside a Future
    
    Returns:
    
    Future containing supplied error
  - isPresent
```
public boolean isPresent()
```
    Specified by:
    
    isPresent in interface Value<T>
  - mkString
```
public java.lang.String mkString()
```
    Description copied from interface: Value
    
    Returns the class name and the name of the subclass, if there is any value, the value is showed between square brackets.
    
    Specified by:
    
    mkString in interface Value<T>
    
    Returns:
    
    String
  - filter
```
public Maybe<T> filter(java.util.function.Predicate<? super T> fn)
```
    Description copied from interface: Filters
    Keep only elements for which the supplied predicates hold e.g.
```
 

     of(1,2,3).filter(i->i>2);

     //[3]

 
 
```
    Specified by:
    
    filter in interface Filters<T>
    
    Specified by:
    
    filter in interface MonadicValue<T>
    
    Parameters:
    
    fn - to filter elements by, retaining matches
    
    Returns:
    
    Filters with elements removed where the predicate does not hold
  - ofType
```
public <U> Maybe<U> ofType(java.lang.Class<? extends U> type)
```
    Description copied from interface: Filters
    Keep only those elements in a stream that are of a given type.
```
 

 // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)

 
 
```
    Specified by:
    
    ofType in interface Filters<T>
  - filterNot
```
public Maybe<T> filterNot(java.util.function.Predicate<? super T> fn)
```
    Description copied from interface: Filters
    Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
 

     of(1,2,3).filter(i->i>2);

     //[1,2]

 
 
```
    Specified by:
    
    filterNot in interface Filters<T>
    
    Parameters:
    
    fn - to filter elements by, retaining matches
    
    Returns:
    
    Filters with elements removed where the predicate does not hold
  - notNull
```
public Maybe<T> notNull()
```
    Description copied from interface: Filters
    Filter elements retaining only values which are not null
```
 

   of(1,2,null,4).nonNull();

   //[1,2,4]

 
 
```
    Specified by:
    
    notNull in interface Filters<T>
    
    Returns:
    
    Filters with nulls removed
  - zipWithPublisher
```
public <U> Future<Tuple2<T,U>> zipWithPublisher(org.reactivestreams.Publisher<? extends U> other)
```
    Specified by:
    
    zipWithPublisher in interface Zippable<T>
  - zip3
```
public <S,U> Future<Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second,
                                        java.lang.Iterable<? extends U> third)
```
    Specified by:
    
    zip3 in interface Zippable<T>
  - zip3
```
public <S,U,R> Future<R> zip3(java.lang.Iterable<? extends S> second,
                              java.lang.Iterable<? extends U> third,
                              Function3<? super T,? super S,? super U,? extends R> fn3)
```
    Specified by:
    
    zip3 in interface Zippable<T>
  - zip4
```
public <T2,T3,T4> Future<Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
                                                  java.lang.Iterable<? extends T3> third,
                                                  java.lang.Iterable<? extends T4> fourth)
```
    Specified by:
    
    zip4 in interface Zippable<T>
  - zip4
```
public <T2,T3,T4,R> Future<R> zip4(java.lang.Iterable<? extends T2> second,
                                   java.lang.Iterable<? extends T3> third,
                                   java.lang.Iterable<? extends T4> fourth,
                                   Function4<? super T,? super T2,? super T3,? super T4,? extends R> fn)
```
    Specified by:
    
    zip4 in interface Zippable<T>
  - zip
```
public <T2,R> Future<R> zip(java.lang.Iterable<? extends T2> app,
                            java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
```
    Description copied from interface: Zippable
    
    Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
    
    Specified by:
    
    zip in interface Zippable<T>
    
    Parameters:
    
    app - to zip with
    
    fn - Zip function
    
    Returns:
    
    Combined zippable
  - zip
```
public <T2,R> Future<R> zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn,
                            org.reactivestreams.Publisher<? extends T2> app)
```
    Description copied from interface: Zippable
    
    Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
    
    Specified by:
    
    zip in interface Zippable<T>
    
    Parameters:
    
    fn - Zip / combining function
    
    app - to combine with
    
    Returns:
    
    Combined zippable
  - of
```
public static <T> Future<T> of(java.util.function.Supplier<T> s)
```
    Create a Future object that asyncrhonously populates using the Common ForkJoinPool from the user provided Supplier
    
    Parameters:
    
    s - Supplier to asynchronously populate results from
    
    Returns:
    
    Future asynchronously populated from the Supplier
  - of
```
public static <T> Future<T> of(java.util.function.Supplier<T> s,
                               java.util.concurrent.Executor ex)
```
    Create a Future object that asyncrhonously populates using the provided Executor and Supplier
    
    Parameters:
    
    s - Supplier to asynchronously populate results from
    
    ex - Executro to asynchronously populate results with
    
    Returns:
    
    Future asynchronously populated from the Supplier
  - async
```
public static <T> Future<T> async(java.util.concurrent.Executor ex,
                                  java.util.function.Supplier<T> s)
```
  - zip
```
public <U> Future<Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
```
    Specified by:
    
    zip in interface Zippable<T>
  - concatMap
```
public <R> Future<R> concatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
```
    Description copied from interface: MonadicValue
    A flattening transformation operation that takes the first value from the returned Iterable.
```
 
   Maybe.just(1).map(i->i+2).concatMap(i->Arrays.asList(()->i*3,20);
   //Maybe[9]

 
```
    Specified by:
    
    concatMap in interface MonadicValue<T>
    
    Parameters:
    
    mapper - transformation function
    
    Returns:
    
    MonadicValue
  - mergeMap
```
public <R> Future<R> mergeMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
```
    Description copied from interface: MonadicValue
    A flattening transformation operation that takes the first value from the returned Publisher.
```
 
   Future.ofResult(1).map(i->i+2).mergeMap(i->Flux.just(()->i*3,20);
   //Future[9]

 
```
    Specified by:
    
    mergeMap in interface MonadicValue<T>
    
    Parameters:
    
    mapper - transformation function
    
    Returns:
    
    MonadicValue
  - getFuture
```
public java.util.concurrent.CompletableFuture<T> getFuture()
```
  - fold
```
public <R> R fold(java.util.function.Function<? super T,? extends R> success,
                  java.util.function.Supplier<? extends R> failure)
```
    Specified by:
    
    fold in interface SealedOr<T>
  - narrow
```
public static <T> Future<T> narrow(Future<? extends T> of)
```

Class Future<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.oath.cyclops.types.foldable.To

Methods inherited from interface com.oath.cyclops.types.MonadicValue

Methods inherited from interface com.oath.cyclops.hkt.Higher

Methods inherited from interface com.oath.cyclops.hkt.Convert

Methods inherited from interface com.oath.cyclops.types.functor.ReactiveTransformable

Methods inherited from interface com.oath.cyclops.types.OrElseValue

Methods inherited from interface com.oath.cyclops.types.Value

Constructor Detail

Future

Method Detail

tailRec

widen

subscribe

narrowK

empty

future

anyOf

allOf

firstSuccess

completeExceptionally

fromPublisher

fromIterable

fromPublisher

fromIterable

of

forEach

forEach

forEach

fromTry

schedule

schedule

sequence

sequence

sequence

traverse

accumulateSuccess

accumulate

accumulateSuccess

accumulateSuccess

accumulate

accumulate

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

toMaybe

visitAsync

foldAsync

fold

map

map

getOrElse

get

isSuccess

isDone

isCancelled

cancel

complete

isFailed

unit

emptyUnit

stream

flatten

flatMap

flatMapCf

toEither

toIor

toCompletableFuture

recover

recover

map

peek

toString

ofResult