Future (cyclops-react 2.0.0-MI1 API)

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

Type Parameters:

T - Type of wrapped future value

All Implemented Interfaces:

Convert<Higher<Future.µ,T>>, Higher<Future.µ,T>, Convertable<T>, Filters<T>, Folds<T>, MonadicValue<T>, ConvertableToReactiveSeq<T>, ToStream<T>, To<Future<T>>, Transformable<T>, Unit<T>, Value<T>, Visitable<T>, Zippable<T>, Fn0<T>, java.lang.Iterable<T>, java.util.function.Predicate<T>, java.util.function.Supplier<T>, org.jooq.lambda.function.Function0<T>, org.reactivestreams.Publisher<T>
```
public class Future<T>
extends java.lang.Object
implements To<Future<T>>, MonadicValue<T>, Higher<Future.µ,T>
```
A Wrapper around CompletableFuture that implements cyclops2-react interfaces and provides a more standard api e.g. map instead of thenApply flatMap instead of thenCompose combine instead of thenCombine (applicative functor ap)

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Future.µ

static class Future.Instances
Companion class for creating Type Class instances for working with FutureWs
- Nested classes/interfaces inherited from interface com.aol.cyclops2.types.Value
 Value.ValueImpl<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops2.types.Convertable
 Convertable.SupplierToConvertable<T>
- Nested classes/interfaces inherited from interface cyclops.function.Fn0
 Fn0.FunctionalOperations<R>, Fn0.SupplierKind<R>

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

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(CollectionX<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(CollectionX<Future<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> Future<T>`	`accumulate(Monoid<T> reducer, CollectionX<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(CollectionX<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(CollectionX<Future<T>> fts, Reducer<R> reducer)` Asynchronously accumulate the results only from those Futures which have completed successfully.
`static <T> Future<T>`	`accumulateSuccess(Monoid<T> reducer, CollectionX<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
`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
`<U> Future<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`<R> Future<R>`	`coflatMap(java.util.function.Function<? super MonadicValue<T>,R> mapper)` Perform a coflatMap operation.
`<T2,R> Future<R>`	`combine(Value<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)` Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction Example
`Future<T>`	`combineEager(Monoid<T> monoid, MonadicValue<? extends T> v2)` Eagerly combine two MonadicValues using the supplied monoid (@see ApplicativeFunctor for type appropraite i.e.
`void`	`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
`static <T> Future<T>`	`empty()` An empty Future
`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
`<R> Future<R>`	`flatMapI(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.
`<R> Future<R>`	`flatMapP(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.
`static <R> Future<R>`	`flatten(Future<? extends Future<R>> nested)`
`<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, Fn3<? 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, Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? 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, Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? 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, Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? 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<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 asyncrhonously 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,X extends java.lang.Throwable> Future<T>`	`fromTry(Try<T,X> value, java.util.concurrent.Executor ex)` Deprecated.
`static <T> Future<T>`	`future()` An empty Future
`T`	`get()` Apply this function to the arguments.
`java.util.concurrent.CompletableFuture<T>`	`getFuture()`
`boolean`	`isCancelled()`
`boolean`	`isDone()`
`boolean`	`isFailed()`
`boolean`	`isPresent()`
`boolean`	`isSuccess()`
`java.util.Iterator<T>`	`iterator()`
`<W extends WitnessType<W>> FutureT<W,T>`	`liftM(W witness)`
`<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 map 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
`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>`	`narrowK(Higher<Future.µ,T> future)` Convert the raw Higher Kinded Type for FutureType types into the FutureType type definition class
`Future<MonadicValue<T>>`	`nest()` cojoin pattern.
`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>`	`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
`static <T> Future<T>`	`ofSupplier(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>`	`ofSupplier(java.util.function.Supplier<T> s, java.util.concurrent.Executor ex)` Create a Future object that asyncrhonously populates using the provided Executor and Supplier
`<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
`static <T> Future<ListX<T>>`	`quorum(java.util.function.Predicate<Status<T>> breakout, Future<T>... fts)` Block until a Quorum of results have returned as determined by the provided Predicate
`Future<T>`	`recover(java.util.function.Function<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.
`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<ListX<T>>`	`sequence(CollectionX<Future<T>> fts)` Asynchronous sequence operation that convert a Collection of FutureWs to a Future with a List
`static <T> Future<ReactiveSeq<T>>`	`sequence(java.util.stream.Stream<? extends Future<T>> fts)` Sequence operation that convert a Stream of FutureWs to a Future with a Stream
`ReactiveSeq<T>`	`stream()`
`java.util.concurrent.CompletableFuture<T>`	`toCompletableFuture()`
`java.util.concurrent.CompletableFuture<T>`	`toCompletableFutureAsync()`
`java.util.concurrent.CompletableFuture<T>`	`toCompletableFutureAsync(java.util.concurrent.Executor exec)`
`Future<T>`	`toFuture()`
`Future<T>`	`toFutureWAsync()`
`Future<T>`	`toFutureWAsync(java.util.concurrent.Executor ex)` This convertable converted to a Future asyncrhonously using the supplied Executor
`Ior<java.lang.Throwable,T>`	`toIor()` Return an Ior that can be this object or a Ior.primary or Ior.secondary
`java.util.Optional<T>`	`toOptional()`
`java.lang.String`	`toString()`
`Xor<java.lang.Throwable,T>`	`toXor()`
`<R> Future<R>`	`trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`<T> Future<T>`	`unit(T unit)`
`<R> R`	`visit(java.util.function.Function<T,R> success, java.util.function.Function<java.lang.Throwable,R> failure)` Blocking analogue to visitAsync.
`<R> Future<R>`	`visitAsync(java.util.function.Function<T,R> success, java.util.function.Function<java.lang.Throwable,R> failure)` Non-blocking visit on the state of this Future
`Future<T>`	`zip(java.util.function.BinaryOperator<Zippable<T>> combiner, Zippable<T> app)` Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout Semigroups and Monoids for a large number of canned combinations).
`<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<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)` Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
`<T2,R> Future<R>`	`zipP(org.reactivestreams.Publisher<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`<U> Future<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipS(java.util.stream.Stream<? extends U> other)` Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
`<U,R> Future<R>`	`zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Stream, using the supplied combining function

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

Methods inherited from interface com.aol.cyclops2.types.To
to

Methods inherited from interface com.aol.cyclops2.types.MonadicValue
flatMapS

Methods inherited from interface com.aol.cyclops2.types.Value
apply, generate, iterate, newSubscriber, of, subscribe, test, toEvalAlways, toEvalLater, toEvalNow, toMaybe, toTry, toTry, toTry, toXor

Methods inherited from interface com.aol.cyclops2.types.Folds
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, xMatch

Methods inherited from interface com.aol.cyclops2.types.stream.ToStream
futureStream, getStreamable, isEmpty, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface com.aol.cyclops2.types.Convertable
collect, fromSupplier, orElse, orElseGet, orElseThrow, toStream, visit

Methods inherited from interface cyclops.function.Fn0
andThen, fnTo, functionOps, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, run, suspend, λ, λv

Methods inherited from interface org.jooq.lambda.function.Function0
apply, from, toSupplier

Methods inherited from interface java.util.function.Predicate
and, isEqual, negate, or

Methods inherited from interface com.aol.cyclops2.types.Zippable
zip3, zip3, zip4, zip4, zipP, zipWith, zipWithP, zipWithS

Methods inherited from interface com.aol.cyclops2.types.Transformable
retry, retry

Methods inherited from interface com.aol.cyclops2.hkt.Higher
apply_, apply, transform

Methods inherited from interface com.aol.cyclops2.hkt.Convert
convert

- Constructor Detail
 - Future
```
public Future()
```
- Method Detail
 - liftM
```
public <W extends WitnessType<W>> FutureT<W,T> liftM(W witness)
```
 - narrowK
```
public static <T> Future<T> narrowK(Higher<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 empty Future
 
 Returns:
 
 A Future that wraps a CompletableFuture with a null result
 - future
```
public static <T> Future<T> future()
```
 An empty 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 - FutureWs 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 - FutureWs 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...)
 - quorum
```
@SafeVarargs
public static <T> Future<ListX<T>> quorum(java.util.function.Predicate<Status<T>> breakout,
 Future<T>... fts)
```
 Block until a Quorum of results have returned as determined by the provided Predicate
```
 
 
 Future<ListX<Integer>> strings = Future.quorum(status -> status.getCompleted() >0, Future.ofSupplier(()->1),Future.future(),Future.future());
 

 strings.get().size()
 //1
 
 
 
```
 Parameters:
 
 breakout - Predicate that determines whether the block should be continued or removed
 
 fts - FutureWs to wait on results from
 
 Returns:
 
 Future which will be populated with a Quorum of results
 - 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.ofSupplier(()->1),ft);
 
 ft.complete(10);
 result.get() //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
 
 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 asyncrhonously 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<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
 - fromTry
```
@Deprecated
public static <T,X extends java.lang.Throwable> Future<T> fromTry(Try<T,X> value,
 java.util.concurrent.Executor ex)
```
 Deprecated.
 
 Construct a Future asyncrhonously from the Supplied Try
 
 Parameters:
 
 value - Try to populate Future from
 
 ex - Executor to execute
 
 Returns:
 
 Future populated with either the value or error in provided Try
 - 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 either 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<ListX<T>> sequence(CollectionX<Future<T>> fts)
```
 Asynchronous sequence operation that convert a Collection of FutureWs to a Future with a List
```
 
 Future<ListX<Integer>> futures =Future.sequence(ListX.of(Future.ofResult(10),Future.ofResult(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> Future<ReactiveSeq<T>> sequence(java.util.stream.Stream<? extends Future<T>> fts)
```
 Sequence operation that convert a Stream of FutureWs to a Future with a Stream
```
 
 Future<Integer> just = Future.ofResult(10);
 Future<ReactiveSeq<Integer>> futures =Future.sequence(Stream.of(just,Future.ofResult(1)));
 //ListX.of(10,1)
 
 
 
```
 Parameters:
 
 fts - Strean of Futures to Sequence into a Future with a Stream
 
 Returns:
 
 Future with a Stream
 - accumulateSuccess
```
public static <T,R> Future<R> accumulateSuccess(CollectionX<Future<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 Future with an error
```
 
 
 Future<Integer> just =Future.of(CompletableFuture.completedFuture(10));
 Future<Integer> none = Future.ofError(new NoSuchElementException());
 
 Future<PSetX<Integer>> futures = Future.accumulateSuccess(ListX.of(just,none,Future.ofResult(1)),Reducers.toPSetX());
 
 //Future[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> Future<R> accumulate(CollectionX<Future<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
```
 
 
 Future<Integer> just =Future.of(CompletableFuture.completedFuture(10));
 Future<Integer> none = Future.ofError(new NoSuchElementException());
 
 Future<PSetX<Integer>> futures = Future.accumulateSuccess(ListX.of(just,none,Future.ofResult(1)),Reducers.toPSetX());
 
 //Future[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
 - accumulateSuccess
```
public static <T,R> Future<R> accumulateSuccess(CollectionX<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(ListX.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,
 CollectionX<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, ListX.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(CollectionX<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(ListX.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,
 CollectionX<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,ListX.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,
 Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
 Fn4<? 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,
 Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
 Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
 Fn4<? 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 apply 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,
 Fn3<? 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,
 Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
 Fn3<? 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 apply 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>
 
 filterFunction - Filter to apply 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
 - visitAsync
```
public <R> Future<R> visitAsync(java.util.function.Function<T,R> success,
 java.util.function.Function<java.lang.Throwable,R> failure)
```
 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
 - visit
```
public <R> R visit(java.util.function.Function<T,R> success,
 java.util.function.Function<java.lang.Throwable,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
 - coflatMap
```
public <R> Future<R> coflatMap(java.util.function.Function<? super MonadicValue<T>,R> mapper)
```
 Description copied from interface: MonadicValue
 Perform a coflatMap operation. The mapping function accepts this MonadicValue and returns a single value to be wrapped inside a Monad.
```
 
 Maybe.none().coflatMap(m -> m.isPresent() ? m.get() : 10);
 //Maybe[10]
 
 
```
 Specified by:
 
 coflatMap in interface MonadicValue<T>
 
 Parameters:
 
 mapper - Mapping / transformation function
 
 Returns:
 
 MonadicValue wrapping return value from transformation function applied to the value inside this MonadicValue
 - nest
```
public Future<MonadicValue<T>> nest()
```
 Description copied from interface: MonadicValue
 
 cojoin pattern. Nests this Monad inside another.
 
 Specified by:
 
 nest in interface MonadicValue<T>
 
 Returns:
 
 Nested Monad
 - combineEager
```
public Future<T> combineEager(Monoid<T> monoid,
 MonadicValue<? extends T> v2)
```
 Description copied from interface: MonadicValue
 Eagerly combine two MonadicValues using the supplied monoid (@see ApplicativeFunctor for type appropraite i.e. lazy / async alternatives)
```
 
 
 Monoid<Integer> add = Monoid.of(1,Semigroups.intSum);
 Maybe.of(10).combineEager(add,Maybe.none());
 //Maybe[10]
 
 Maybe.none().combineEager(add,Maybe.of(10));
 //Maybe[10]
 
 Maybe.none().combineEager(add,Maybe.none());
 //Maybe.none()
 
 Maybe.of(10).combineEager(add,Maybe.of(10));
 //Maybe[20]
 
 Monoid<Integer> firstNonNull = Monoid.of(null , Semigroups.firstNonNull());
 Maybe.of(10).combineEager(firstNonNull,Maybe.of(10));
 //Maybe[10]
 
```
 Specified by:
 
 combineEager in interface MonadicValue<T>
 
 Returns:
 - 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 MonadicValue<T>
 
 Specified by:
 
 map in interface Transformable<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 map operation
 
 Parameters:
 
 fn - Transformation function
 
 ex - Executor to execute the transformation asynchronously
 
 Returns:
 
 Mapped Future
 
 See Also:
 
 CompletableFuture.thenApplyAsync(Function, Executor)
 - get
```
public T get()
```
 Description copied from interface: org.jooq.lambda.function.Function0
 
 Apply this function to the arguments.
 
 Specified by:
 
 get in interface Convertable<T>
 
 Specified by:
 
 get in interface java.util.function.Supplier<T>
 
 Specified by:
 
 get in interface org.jooq.lambda.function.Function0<T>
 
 Returns:
 
 Contained value, maybe null
 - isSuccess
```
public boolean isSuccess()
```
 Returns:
 
 true if this Future is both complete, and completed without an Exception
 - isDone
```
public boolean isDone()
```
 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 void complete(T value)
```
 If not already completed, sets the value of this Future to the provided value
 
 Parameters:
 
 value - Value to set this Future to
 - isFailed
```
public boolean isFailed()
```
 Returns:
 
 true if this Future is complete, but completed with an Exception
 - iterator
```
public java.util.Iterator<T> iterator()
```
 Specified by:
 
 iterator in interface Convertable<T>
 
 Specified by:
 
 iterator in interface Value<T>
 
 Specified by:
 
 iterator in interface java.lang.Iterable<T>
 - unit
```
public <T> Future<T> unit(T unit)
```
 Specified by:
 
 unit in interface MonadicValue<T>
 
 Specified by:
 
 unit in interface Unit<T>
 - stream
```
public ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface ToStream<T>
 
 Specified by:
 
 stream in interface Value<T>
 
 Returns:
 
 ReactiveSeq from this Streamable
 - 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
 - toXor
```
public Xor<java.lang.Throwable,T> toXor()
```
 Specified by:
 
 toXor in interface Value<T>
 
 Returns:
 
 Primary Xor that has the same value as this Value
 - toIor
```
public Ior<java.lang.Throwable,T> toIor()
```
 Description copied from interface: Value
 
 Return an Ior that can be this object or a Ior.primary or Ior.secondary
 
 Specified by:
 
 toIor in interface Value<T>
 
 Returns:
 
 new Ior
 - toFuture
```
public Future<T> toFuture()
```
 Specified by:
 
 toFuture in interface Convertable<T>
 
 Returns:
 
 This convertable converted to a Future
 - toCompletableFuture
```
public java.util.concurrent.CompletableFuture<T> toCompletableFuture()
```
 Specified by:
 
 toCompletableFuture in interface Convertable<T>
 
 Returns:
 
 A CompletableFuture, populated immediately by a call to get
 - toCompletableFutureAsync
```
public java.util.concurrent.CompletableFuture<T> toCompletableFutureAsync()
```
 Specified by:
 
 toCompletableFutureAsync in interface Convertable<T>
 
 Returns:
 
 A CompletableFuture populated asynchronously on the Common ForkJoinPool by calling get
 - toCompletableFutureAsync
```
public java.util.concurrent.CompletableFuture<T> toCompletableFutureAsync(java.util.concurrent.Executor exec)
```
 Specified by:
 
 toCompletableFutureAsync in interface Convertable<T>
 
 Parameters:
 
 exec - Executor to asyncrhonously populate the CompletableFuture
 
 Returns:
 
 A CompletableFuture populated asynchronously on the supplied Executor by calling get
 - recover
```
public Future<T> recover(java.util.function.Function<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, transform the returned Future also completes normally with the same value.
```
 
 Future.ofError(new RuntimeException())
 .recover(__ -> true)
 
 //Future[true]
 
 
 
```
 Parameters:
 
 fn - the function to use to compute the value of the returned Future if this Future completed exceptionally
 
 Returns:
 
 the new Future
 - 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 futureW mapped to a new state
 - cast
```
public  Future cast(java.lang.Class<? extends U> type)
```
 Description copied from interface: Transformable
 
 Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)
 
 Specified by:
 
 cast in interface Transformable<T>
 - 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
 - trampoline
```
public <R> Future<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
```
 Description copied from interface: Transformable
 Performs a map operation that can call a recursive method without running out of stack space
```
 
 ReactiveSeq.of(10,20,30,40)
 			 .trampoline(i-> fibonacci(i))
 			 .forEach(System.out::println); 
 			 
 	Trampoline<Long> fibonacci(int i){
 		return fibonacci(i,1,0);
 	}
 	Trampoline<Long> fibonacci(int n, long a, long b) {
 	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
 	}		 
 			 
 55
 	6765
 	832040
 	102334155
 
 
 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
 			 .trampoline(i-> fibonacci(i))
 			 .forEach(System.out::println);
 			 
 			 
 completes successfully
 
 
```
 Specified by:
 
 trampoline in interface Transformable<T>
 
 Parameters:
 
 mapper - TCO Transformation function
 
 Returns:
 
 Transformable transformed by the supplied transformation function
 - 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 Convertable<T>
 
 Returns:
 
 True if value exists and is non-null
 - 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  Maybe 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
 - toOptional
```
public java.util.Optional<T> toOptional()
```
 Specified by:
 
 toOptional in interface Convertable<T>
 
 Returns:
 
 Optional that wraps contained value, Optional.empty if value is null
 - toFutureWAsync
```
public Future<T> toFutureWAsync()
```
 Specified by:
 
 toFutureWAsync in interface Convertable<T>
 
 Returns:
 
 This convertable converted to a Future asyncrhonously
 - toFutureWAsync
```
public Future<T> toFutureWAsync(java.util.concurrent.Executor ex)
```
 Description copied from interface: Convertable
 
 This convertable converted to a Future asyncrhonously using the supplied Executor
 
 Specified by:
 
 toFutureWAsync in interface Convertable<T>
 
 Parameters:
 
 ex - Executor to execute the conversion on
 
 Returns:
 
 This convertable converted to a Future asyncrhonously
 - combine
```
public <T2,R> Future<R> combine(Value<? extends T2> app,
 java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
```
 Description copied from interface: MonadicValue
 Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction Example
```
 
 Maybe<Integer> some = Maybe.just(10);
 just.combine(Eval.now(20), this::add);
 //Some[30]

 Maybe<Integer> none = Maybe.none();
 none.combine(Eval.now(20), this::add);
 //None

 
 
```
 Specified by:
 
 combine in interface MonadicValue<T>
 
 Parameters:
 
 app - Value to combine with this one.
 
 fn - BiFunction to combine them
 
 Returns:
 
 New Applicativefunctor that represents the combined values
 - 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 MonadicValue<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 app - to zip with
 
 fn - Zip function
 
 Returns:
 
 Combined zippable
 - zipP
```
public <T2,R> Future<R> zipP(org.reactivestreams.Publisher<? 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 Publisher, using the supplied combining function
 
 Specified by:
 
 zipP in interface MonadicValue<T>
 
 Specified by:
 
 zipP in interface Zippable<T>
 
 Parameters:
 
 app - to combine with
 
 fn - Zip / combining function
 
 Returns:
 
 Combined zippable
 - ofSupplier
```
public static <T> Future<T> ofSupplier(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
 - ofSupplier
```
public static <T> Future<T> ofSupplier(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
 - zipS
```
public <U,R> Future<R> zipS(java.util.stream.Stream<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
 
 Specified by:
 
 zipS in interface Zippable<T>
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zipS
```
public  Future<org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
 
 Specified by:
 
 zipS in interface Zippable<T>
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - zip
```
public  Future<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Iterable to combine with
 
 Returns:
 - flatMapI
```
public <R> Future<R> flatMapI(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).flatMapI(i->Arrays.asList(()->i*3,20);
 //Maybe[9]
 
 
```
 Specified by:
 
 flatMapI in interface MonadicValue<T>
 
 Parameters:
 
 mapper - transformation function
 
 Returns:
 
 MonadicValue
 - flatMapP
```
public <R> Future<R> flatMapP(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.
```
 
 FutureW.ofResult(1).map(i->i+2).flatMapP(i->Flux.just(()->i*3,20);
 //FutureW[9]
 
 
```
 Specified by:
 
 flatMapP in interface MonadicValue<T>
 
 Parameters:
 
 mapper - transformation function
 
 Returns:
 
 MonadicValue
 - zip
```
public Future<T> zip(java.util.function.BinaryOperator<Zippable<T>> combiner,
 Zippable<T> app)
```
 Description copied from interface: Zippable
 
 Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout Semigroups and Monoids for a large number of canned combinations). If this Applicative is a scalar value the provided value is combined with that value, otherwise the value is combined pair wise with all value in a non-scalar datastructure
 Specified by:
 
 zip in interface Zippable<T>
 
 Returns:
 
 See Also:
 Semigroup, Semigroups, Monoid, To lift any Semigroup (or monoid) up to handling Applicatives use the combineApplicatives operator in Semigroups {@see com.aol.cyclops2.Semigroups#combineApplicatives(BiFunction) } or Monoids { {@see com.aol.cyclops2.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops2.function.Monoid) } {@code BinaryOperator> sumMaybes = Semigroups.combineScalarFunctors(Semigroups.intSum); Maybe.just(1).zip(sumMaybes, Maybe.just(5)) //Maybe.just(6)); }
 - getFuture
```
public java.util.concurrent.CompletableFuture<T> getFuture()
```

Class Future<T>

Nested Class Summary

Nested classes/interfaces inherited from interface com.aol.cyclops2.types.Value

Nested classes/interfaces inherited from interface com.aol.cyclops2.types.Convertable

Nested classes/interfaces inherited from interface cyclops.function.Fn0

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.aol.cyclops2.types.To

Methods inherited from interface com.aol.cyclops2.types.MonadicValue

Methods inherited from interface com.aol.cyclops2.types.Value

Methods inherited from interface com.aol.cyclops2.types.Folds

Methods inherited from interface com.aol.cyclops2.types.stream.ToStream

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.aol.cyclops2.types.Convertable

Methods inherited from interface cyclops.function.Fn0

Methods inherited from interface org.jooq.lambda.function.Function0

Methods inherited from interface java.util.function.Predicate

Methods inherited from interface com.aol.cyclops2.types.Zippable

Methods inherited from interface com.aol.cyclops2.types.Transformable

Methods inherited from interface com.aol.cyclops2.hkt.Higher

Methods inherited from interface com.aol.cyclops2.hkt.Convert

Constructor Detail

Future

Method Detail

liftM

narrowK

empty

future

anyOf

allOf

quorum

firstSuccess

completeExceptionally

fromPublisher

fromIterable

fromPublisher

fromIterable

of

fromTry

fromTry

schedule

schedule

sequence

sequence

accumulateSuccess

accumulate

accumulateSuccess

accumulateSuccess

accumulate

accumulate

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

visitAsync

visit

coflatMap

nest

combineEager

map

map

get

isSuccess

isDone

isCancelled

cancel

complete

isFailed

iterator

unit

stream

flatten

flatMap

flatMapCf

toXor

toIor

toFuture