FutureW (cyclops-react 1.0.2 API)

java.lang.Object
- com.aol.cyclops.control.FutureW<T>

Type Parameters:

T - Type of wrapped future value

All Implemented Interfaces:

ApplicativeFunctor<T>, Combiner<T>, Convertable<T>, ConvertableFunctor<T>, Filterable<T>, FlatMap<T>, Foldable<T>, Functor<T>, MonadicValue<T>, MonadicValue1<T>, To<FutureW<T>>, Unit<T>, Value<T>, Visitable<T>, Zippable<T>, java.lang.Iterable<T>, java.util.function.Predicate<T>, java.util.function.Supplier<T>, org.reactivestreams.Publisher<T>
```
public class FutureW<T>
extends java.lang.Object
implements To<FutureW<T>>, ConvertableFunctor<T>, ApplicativeFunctor<T>, MonadicValue1<T>, FlatMap<T>, Filterable<T>
```
A Wrapper around CompletableFuture that implements cyclops-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/interfaces inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor
 ApplicativeFunctor.Applicatives, ApplicativeFunctor.ApplyFunctions<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.Value
 Value.ValueImpl<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.Convertable
 Convertable.SupplierToConvertable<T>

Constructor Summary

Constructors
Constructor and Description

FutureW()

Constructors
Constructor and Description
`FutureW()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T,R> FutureW<R>`	`accumulate(CollectionX<FutureW<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 FutureW 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) `Monoids`.
`static <T,R> FutureW<R>`	`accumulate(CollectionX<FutureW<T>> fts, Reducer<R> reducer)` Asynchronously accumulate the results of Futures, a single failure will cause a failed result, using the supplied Reducer `Reducers`
`static <T> FutureW<T>`	`accumulate(Monoid<T> reducer, CollectionX<FutureW<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) `Monoids` A single Failure results in a Failed Future.
`static <T,R> FutureW<R>`	`accumulateSuccess(CollectionX<FutureW<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 FutureW 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) `Monoids`.
`static <T,R> FutureW<R>`	`accumulateSuccess(CollectionX<FutureW<T>> fts, Reducer<R> reducer)` Asynchronously accumulate the results only from those Futures which have completed successfully.
`static <T> FutureW<T>`	`accumulateSuccess(Monoid<T> reducer, CollectionX<FutureW<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) `Monoids`.
`static <T> FutureW<T>`	`allOf(FutureW<T>... fts)` Wait until all the provided FutureW's to complete
`static <T> FutureW<T>`	`anyOf(FutureW<T>... fts)` Select the first FutureW to complete
`void`	`cancel()` If not already completed, completes this FutureW 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> FutureW<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`<R> FutureW<R>`	`coflatMap(java.util.function.Function<? super MonadicValue<T>,R> mapper)` Perform a coflatMap operation.
`FutureW<T>`	`combine(java.util.function.BinaryOperator<Combiner<T>> combiner, Combiner<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> FutureW<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
`FutureW<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 FutureW to the provided value
`boolean`	`completeExceptionally(java.lang.Throwable e)` Complete this FutureW with an Exception
`static <T> FutureW<T>`	`empty()` An empty FutureW
`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> FutureW<T>`	`firstSuccess(FutureW<T>... fts)` Select the first Future to return with a successful result
`<R> FutureW<R>`	`flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends R>> mapper)` A flattening transformation operation (@see `Optional.flatMap(Function)`
`<R> FutureW<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> FutureW<R>`	`flatMapIterable(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> FutureW<R>`	`flatMapPublisher(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.
`<R> FutureW<R>`	`flatten()`
`static <T> FutureW<T>`	`fromIterable(java.lang.Iterable<T> iterable)` Construct a FutureW syncrhonously that contains a single value extracted from the supplied Iterable
`static <T> FutureW<T>`	`fromIterable(java.lang.Iterable<T> iterable, java.util.concurrent.Executor ex)` Construct a FutureW asyncrhonously that contains a single value extracted from the supplied Iterable
`static <T> FutureW<T>`	`fromPublisher(org.reactivestreams.Publisher<T> pub)` Construct a FutureW syncrhonously that contains a single value extracted from the supplied reactive-streams Publisher
`static <T> FutureW<T>`	`fromPublisher(org.reactivestreams.Publisher<T> pub, java.util.concurrent.Executor ex)` Construct a FutureW asyncrhonously that contains a single value extracted from the supplied reactive-streams Publisher
`static <T,X extends java.lang.Throwable> FutureW<T>`	`fromTry(Try<T,X> value)` Construct a FutureW syncrhonously from the Supplied Try
`static <T,X extends java.lang.Throwable> FutureW<T>`	`fromTry(Try<T,X> value, java.util.concurrent.Executor ex)` Deprecated.
`static <T> FutureW<T>`	`future()` An empty FutureW
`T`	`get()`
`boolean`	`isCancelled()`
`boolean`	`isDone()`
`boolean`	`isFailed()`
`boolean`	`isPresent()`
`boolean`	`isSuccess()`
`java.util.Iterator<T>`	`iterator()`
`<R> FutureW<R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> FutureW<R>`	`map(java.util.function.Function<? super T,? extends R> fn, java.util.concurrent.Executor ex)` Asyncrhonous map operation
`<R> FutureW<R>`	`map(java.util.function.Function<? super T,R> success, java.util.function.Function<java.lang.Throwable,R> failure)` Map this FutureW differently depending on whether the previous stage completed successfully or failed
`<R> FutureW<R>`	`matches(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> successCase, java.util.function.Function<Matchable.CheckValue1<java.lang.Throwable,R>,Matchable.CheckValue1<java.lang.Throwable,R>> failureCase, java.util.function.Supplier<? extends R> otherwise)` Asychronously pattern match on the value inside this FutureW once it becomes available.
`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.
`FutureW<MonadicValue<T>>`	`nest()` cojoin pattern.
`Maybe<T>`	`notNull()` Filter elements retaining only values which are not null
`static <T> FutureW<T>`	`of(java.util.concurrent.CompletableFuture<T> f)` Create a FutureW instance from the supplied CompletableFuture
`static <T> FutureW<T>`	`ofError(java.lang.Throwable error)` Construct a completed-with-error FutureW from the given Exception
`static <T> FutureW<T>`	`ofResult(T result)` Construct a successfully completed FutureW from the given value
`static <T> FutureW<T>`	`ofSupplier(java.util.function.Supplier<T> s)` Create a FutureW object that asyncrhonously populates using the Common ForkJoinPool from the user provided Supplier
`static <T> FutureW<T>`	`ofSupplier(java.util.function.Supplier<T> s, java.util.concurrent.Executor ex)` Create a FutureW 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.
`<R> FutureW<R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`FutureW<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Functor, without transforming it
`static <T> FutureW<ListX<T>>`	`quorum(java.util.function.Predicate<Status<T>> breakout, FutureW<T>... fts)` Block until a Quorum of results have returned as determined by the provided Predicate
`FutureW<T>`	`recover(java.util.function.Function<java.lang.Throwable,? extends T> fn)` Returns a new FutureW that, when this FutureW completes exceptionally is executed with this FutureW exception as the argument to the supplied function.
`static <T> FutureW<T>`	`schedule(long delay, java.util.concurrent.ScheduledExecutorService ex, java.util.function.Supplier<T> t)` Schedule the population of a FutureW from the provided Supplier after the specified delay.
`static <T> FutureW<T>`	`schedule(java.lang.String cron, java.util.concurrent.ScheduledExecutorService ex, java.util.function.Supplier<T> t)` Schedule the population of a FutureW from the provided Supplier, the provided Cron (Quartz format) expression will be used to trigger the population of the FutureW.
`static <T> FutureW<ListX<T>>`	`sequence(CollectionX<FutureW<T>> fts)` Asynchronous sequence operation that convert a Collection of FutureWs to a FutureW with a List
`static <T> FutureW<ReactiveSeq<T>>`	`sequence(java.util.stream.Stream<FutureW<T>> fts)` Sequence operation that convert a Stream of FutureWs to a FutureW 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)`
`FutureW<T>`	`toFutureW()`
`FutureW<T>`	`toFutureWAsync()`
`FutureW<T>`	`toFutureWAsync(java.util.concurrent.Executor ex)` This convertable converted to a FutureW 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> FutureW<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> FutureW<T>`	`unit(T unit)`
`<T2,R> FutureW<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> FutureW<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> FutureW<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
`<U> FutureW<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<? extends U> other)` Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
`<U,R> FutureW<R>`	`zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Seq, using the supplied combining function
`<U> FutureW<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.util.stream.Stream<? extends U> other)` Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
`<U,R> FutureW<R>`	`zip(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.cyclops.types.To
to

Methods inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor
applyFunctions

Methods inherited from interface com.aol.cyclops.types.MonadicValue1
anyM

Methods inherited from interface com.aol.cyclops.types.Value
collect, fold, fold, generate, iterate, mapReduce, newSubscriber, of, subscribe, test, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFeatureToggle, toFutureStream, toFutureStream, toLazyImmutable, toList, toListX, toMaybe, toMutable, toPBagX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toTry, toTry, toTry, toXor, unapply

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

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

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

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

- Constructor Detail
 - FutureW
```
public FutureW()
```
- Method Detail
 - empty
```
public static <T> FutureW<T> empty()
```
 An empty FutureW
 
 Returns:
 
 A FutureW that wraps a CompletableFuture with a null result
 - future
```
public static <T> FutureW<T> future()
```
 An empty FutureW
 
 Returns:
 
 A FutureW that wraps a CompletableFuture with a null result
 - anyOf
```
public static <T> FutureW<T> anyOf(FutureW<T>... fts)
```
 Select the first FutureW to complete
 
 Parameters:
 
 fts - FutureWs to race
 
 Returns:
 
 First FutureW to complete
 
 See Also:
 
 CompletableFuture.anyOf(CompletableFuture...)
 - allOf
```
public static <T> FutureW<T> allOf(FutureW<T>... fts)
```
 Wait until all the provided FutureW's to complete
 
 Parameters:
 
 fts - FutureWs to wait on
 
 Returns:
 
 FutureW that completes when all the provided Futures Complete. Empty Future result, or holds an Exception from a provided FutureW that failed.
 
 See Also:
 
 CompletableFuture.allOf(CompletableFuture...)
 - quorum
```
@SafeVarargs
public static <T> FutureW<ListX<T>> quorum(java.util.function.Predicate<Status<T>> breakout,
 FutureW<T>... fts)
```
 Block until a Quorum of results have returned as determined by the provided Predicate
```
 
 
 FutureW<ListX<Integer>> strings = FutureW.quorum(status -> status.getCompleted() >0, FutureW.ofSupplier(()->1),FutureW.future(),FutureW.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:
 
 FutureW which will be populated with a Quorum of results
 - firstSuccess
```
@SafeVarargs
public static <T> FutureW<T> firstSuccess(FutureW<T>... fts)
```
 Select the first Future to return with a successful result
```
 
 FutureW<Integer> ft = FutureW.future();
 FutureW<Integer> result = FutureW.firstSuccess(FutureW.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 FutureW with an Exception
 
 Parameters:
 
 e - Throwable to complete this FutureW with
 
 See Also:
 
 CompletableFuture.completeExceptionally(Throwable)
 - fromPublisher
```
public static <T> FutureW<T> fromPublisher(org.reactivestreams.Publisher<T> pub,
 java.util.concurrent.Executor ex)
```
 Construct a FutureW asyncrhonously that contains a single value extracted from the supplied reactive-streams Publisher
```
 
 ReactiveSeq<Integer> stream = ReactiveSeq.of(1,2,3);
 
 FutureW<Integer> future = FutureW.fromPublisher(stream,ex);
 
 //FutureW[1]
 
 
 
```
 Parameters:
 
 pub - Publisher to extract value from
 
 ex - Executor to extract value on
 
 Returns:
 
 FutureW populated asyncrhonously from Publisher
 - fromIterable
```
public static <T> FutureW<T> fromIterable(java.lang.Iterable<T> iterable,
 java.util.concurrent.Executor ex)
```
 Construct a FutureW asyncrhonously that contains a single value extracted from the supplied Iterable
```
 
 ReactiveSeq<Integer> stream = ReactiveSeq.of(1,2,3);
 
 FutureW<Integer> future = FutureW.fromIterable(stream,ex);
 
 //FutureW[1]
 
 
 
```
 Parameters:
 
 iterable - Iterable to generate a FutureW from
 
 ex - Executor to extract value on
 
 Returns:
 
 FutureW populated asyncrhonously from Iterable
 - fromPublisher
```
public static <T> FutureW<T> fromPublisher(org.reactivestreams.Publisher<T> pub)
```
 Construct a FutureW syncrhonously that contains a single value extracted from the supplied reactive-streams Publisher
```
 
 ReactiveSeq<Integer> stream = ReactiveSeq.of(1,2,3);
 
 FutureW<Integer> future = FutureW.fromPublisher(stream);
 
 //FutureW[1]
 
 
 
```
 Parameters:
 
 pub - Publisher to extract value from
 
 Returns:
 
 FutureW populated syncrhonously from Publisher
 - fromIterable
```
public static <T> FutureW<T> fromIterable(java.lang.Iterable<T> iterable)
```
 Construct a FutureW syncrhonously that contains a single value extracted from the supplied Iterable
```
 
 ReactiveSeq<Integer> stream = ReactiveSeq.of(1,2,3);
 
 FutureW<Integer> future = FutureW.fromIterable(stream);
 
 //FutureW[1]
 
 
 
```
 Parameters:
 
 iterable - Iterable to extract value from
 
 Returns:
 
 FutureW populated syncrhonously from Iterable
 - of
```
public static <T> FutureW<T> of(java.util.concurrent.CompletableFuture<T> f)
```
 Create a FutureW instance from the supplied CompletableFuture
 
 Parameters:
 
 f - CompletableFuture to wrap as a FutureW
 
 Returns:
 
 FutureW wrapping the supplied CompletableFuture
 - fromTry
```
@Deprecated
public static <T,X extends java.lang.Throwable> FutureW<T> fromTry(Try<T,X> value,
 java.util.concurrent.Executor ex)
```
 Deprecated.
 
 Construct a FutureW asyncrhonously from the Supplied Try
 
 Parameters:
 
 value - Try to populate Future from
 
 ex - Executor to execute
 
 Returns:
 
 FutureW populated with either the value or error in provided Try
 - fromTry
```
public static <T,X extends java.lang.Throwable> FutureW<T> fromTry(Try<T,X> value)
```
 Construct a FutureW syncrhonously from the Supplied Try
 
 Parameters:
 
 value - Try to populate Future from
 
 Returns:
 
 FutureW populated with either the value or error in provided Try
 - schedule
```
public static <T> FutureW<T> schedule(java.lang.String cron,
 java.util.concurrent.ScheduledExecutorService ex,
 java.util.function.Supplier<T> t)
```
 Schedule the population of a FutureW from the provided Supplier, the provided Cron (Quartz format) expression will be used to trigger the population of the FutureW. The provided ScheduledExecutorService provided the thread on which the Supplier will be executed.
```
 
 
 FutureW<String> future = FutureW.schedule("* * * * * ?", Executors.newScheduledThreadPool(1), ()->"hello");
 
 //FutureW["hello"]
 
 
```
 Parameters:
 
 cron - Cron expression in Quartz format
 
 ex - ScheduledExecutorService used to execute the provided Supplier
 
 t - The Supplier to execute to populate the FutureW
 
 Returns:
 
 FutureW populated on a Cron based Schedule
 - schedule
```
public static <T> FutureW<T> schedule(long delay,
 java.util.concurrent.ScheduledExecutorService ex,
 java.util.function.Supplier<T> t)
```
 Schedule the population of a FutureW from the provided Supplier after the specified delay. The provided ScheduledExecutorService provided the thread on which the Supplier will be executed.
```
 
 
 FutureW<String> future = FutureW.schedule(10l, Executors.newScheduledThreadPool(1), ()->"hello");
 
 //FutureW["hello"]
 
 
```
 Parameters:
 
 delay - Delay after which the FutureW should be populated
 
 ex - ScheduledExecutorService used to execute the provided Supplier
 
 t - he Supplier to execute to populate the FutureW
 
 Returns:
 
 FutureW populated after the specified delay
 - sequence
```
public static <T> FutureW<ListX<T>> sequence(CollectionX<FutureW<T>> fts)
```
 Asynchronous sequence operation that convert a Collection of FutureWs to a FutureW with a List
```
 
 FutureW<ListX<Integer>> futures =FutureW.sequence(ListX.of(FutureW.ofResult(10),FutureW.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> FutureW<ReactiveSeq<T>> sequence(java.util.stream.Stream<FutureW<T>> fts)
```
 Sequence operation that convert a Stream of FutureWs to a FutureW with a Stream
```
 
 FutureW<Integer> just = FutureW.ofResult(10);
 FutureW<ReactiveSeq<Integer>> futures =FutureW.sequence(Stream.of(just,FutureW.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> FutureW<R> accumulateSuccess(CollectionX<FutureW<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 FutureW with an error
```
 
 
 FutureW<Integer> just =FutureW.of(CompletableFuture.completedFuture(10));
 FutureW<Integer> none = FutureW.ofError(new NoSuchElementException());
 
 FutureW<PSetX<Integer>> futures = FutureW.accumulateSuccess(ListX.of(just,none,FutureW.ofResult(1)),Reducers.toPSetX());
 
 //FutureW[PSetX[10,1]]
 
 
```
 Parameters:
 
 fts - Collection of Futures to accumulate successes
 
 reducer - Reducer to accumulate results
 
 Returns:
 
 FutureW asynchronously populated with the accumulate success operation
 - accumulate
```
public static <T,R> FutureW<R> accumulate(CollectionX<FutureW<T>> fts,
 Reducer<R> reducer)
```
 Asynchronously accumulate the results of Futures, a single failure will cause a failed result, using the supplied Reducer Reducers
```
 
 
 FutureW<Integer> just =FutureW.of(CompletableFuture.completedFuture(10));
 FutureW<Integer> none = FutureW.ofError(new NoSuchElementException());
 
 FutureW<PSetX<Integer>> futures = FutureW.accumulateSuccess(ListX.of(just,none,FutureW.ofResult(1)),Reducers.toPSetX());
 
 //FutureW[PSetX[10,1]]
 
 
```
 Parameters:
 
 fts - Collection of Futures to accumulate successes
 
 reducer - Reducer to accumulate results
 
 Returns:
 
 FutureW asynchronously populated with the accumulate success operation
 - accumulateSuccess
```
public static <T,R> FutureW<R> accumulateSuccess(CollectionX<FutureW<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 FutureW 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) Monoids.
```
 
 FutureW<String> future = FutureW.accumulate(ListX.of(FutureW.ofResult(10),FutureW.ofResult(1)),i->""+i,Monoids.stringConcat);
 //FutureW["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:
 
 FutureW asynchronously populated with the accumulate operation
 - accumulateSuccess
```
public static <T> FutureW<T> accumulateSuccess(Monoid<T> reducer,
 CollectionX<FutureW<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) Monoids.
```
 
 FutureW<Integer> just =FutureW.of(CompletableFuture.completedFuture(10));
 FutureW<Integer> future =FutureW.accumulate(Monoids.intSum, ListX.of(just,FutureW.ofResult(1)));
 //FutureW[11]
 
 
```
 Parameters:
 
 fts - Collection of Futures to accumulate successes
 
 reducer - Monoid to combine values from each Future
 
 Returns:
 
 FutureW asynchronously populated with the accumulate operation
 - accumulate
```
public static <T,R> FutureW<R> accumulate(CollectionX<FutureW<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 FutureW 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) Monoids. A single Failure results in a Failed Future.
```
 
 FutureW<String> future = FutureW.accumulate(ListX.of(FutureW.ofResult(10),FutureW.ofResult(1)),i->""+i,Monoids.stringConcat);
 //FutureW["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:
 
 FutureW asynchronously populated with the accumulate operation
 - accumulate
```
public static <T> FutureW<T> accumulate(Monoid<T> reducer,
 CollectionX<FutureW<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) Monoids A single Failure results in a Failed Future.
```
 
 FutureW<Integer> future =FutureW.accumulate(Monoids.intSum,ListX.of(just,FutureW.ofResult(1)));
 //FutureW[11]
 
 
```
 Parameters:
 
 fts - Collection of Futures to accumulate successes
 
 reducer - Monoid to combine values from each Future
 
 Returns:
 
 FutureW asynchronously populated with the accumulate operation
 - matches
```
public <R> FutureW<R> matches(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> successCase,
 java.util.function.Function<Matchable.CheckValue1<java.lang.Throwable,R>,Matchable.CheckValue1<java.lang.Throwable,R>> failureCase,
 java.util.function.Supplier<? extends R> otherwise)
```
 Asychronously pattern match on the value inside this FutureW once it becomes available.
```
 
 
 import static com.aol.cyclops.control.Matchable.otherwise;
 import static com.aol.cyclops.control.Matchable.then;
 import static com.aol.cyclops.control.Matchable.when;
 import static com.aol.cyclops.util.function.Predicates.instanceOf;

 FutureW.ofResult(10).matches(c->c.is(when(10),then("hello")),
 c->c.is(when(instanceOf(Throwable.class)), then("error")),
 otherwise("miss"));
 //FutureW["hello"]
 
 FutureW.ofResult(10).matches(c->c.is(when(10),then("hello")).is(when(2),then("hello")),
 c->c.is(when(Predicates.instanceOf(Throwable.class)), then("error")),
 otherwise("miss"));
 //FutureW["hello"]
 
 FutureW.ofResult(10).matches(c->c.is(when(1),then("hello"))
 .is(when(2),then(()->"hello"))
 .is(when(3),then(()->"hello")),
 c->c.is(when(Predicates.instanceOf(Throwable.class)), then("error")),
 otherwise("miss"));
 //FutureW["miss"]
 
 
 
```
 Parameters:
 
 successCase - Pattern matching function executed if this FutureW completes the previous stage successfully
 
 failureCase - Pattern matching function executed if this FutureW completes the previous stage with an exception
 
 otherwise - Supplier used to provide a value if the selecting pattern matching function fails to find a match
 
 Returns:
 
 FutureW containing result asynchronously populated by pattern matching on the result of previous stage
 - coflatMap
```
public <R> FutureW<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>
 
 Specified by:
 
 coflatMap in interface MonadicValue1<T>
 
 Parameters:
 
 mapper - Mapping / transformation function
 
 Returns:
 
 MonadicValue wrapping return value from transformation function applied to the value inside this MonadicValue
 - nest
```
public FutureW<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 FutureW<T> combineEager(Monoid<T> monoid,
 MonadicValue<? extends T> v2)
```
 Description copied from interface: MonadicValue1
 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 MonadicValue1<T>
 
 Returns:
 - map
```
public <R> FutureW<R> map(java.util.function.Function<? super T,? extends R> fn)
```
 Description copied from interface: Functor
 Transform this functor using the supplied transformation function
```
 
 
 
 of(1,2,3).map(i->i*2)
 
 //[2,4,6]
 
 
 
```
 Specified by:
 
 map in interface ConvertableFunctor<T>
 
 Specified by:
 
 map in interface Functor<T>
 
 Specified by:
 
 map in interface MonadicValue<T>
 
 Specified by:
 
 map in interface MonadicValue1<T>
 
 Parameters:
 
 fn - Transformation function
 
 Returns:
 
 Transformed Functor
 - map
```
public <R> FutureW<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 FutureW
 
 See Also:
 
 CompletableFuture.thenApplyAsync(Function, Executor)
 - patternMatch
```
public <R> FutureW<R> patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1,
 java.util.function.Supplier<? extends R> otherwise)
```
 Description copied from interface: Functor
 Transform the elements of this Stream with a Pattern Matching case and default value
```
 
 List<String> result = CollectionX.of(1,2,3,4)
 .patternMatch(
 c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
 )
 
 // CollectionX["odd","even","odd","even"]
 
```
 Specified by:
 
 patternMatch in interface Functor<T>
 
 Parameters:
 
 case1 - Function to generate a case (or chain of cases as a single case)
 
 otherwise - Value if supplied case doesn't match
 
 Returns:
 
 CollectionX where elements are transformed by pattern matching
 - get
```
public T get()
```
 Specified by:
 
 get in interface Convertable<T>
 
 Specified by:
 
 get in interface java.util.function.Supplier<T>
 
 Returns:
 
 Contained value, maybe null
 - isSuccess
```
public boolean isSuccess()
```
 Returns:
 
 true if this FutureW is both complete, and completed without an Exception
 - isDone
```
public boolean isDone()
```
 Returns:
 
 true if this FutureW has completed executing
 
 See Also:
 
 CompletableFuture.isDone()
 - isCancelled
```
public boolean isCancelled()
```
 Returns:
 
 True if this FutureW has been cancelled
 
 See Also:
 
 CompletableFuture.isCancelled()
 - cancel
```
public void cancel()
```
 If not already completed, completes this FutureW 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 FutureW to the provided value
 
 Parameters:
 
 value - Value to set this FutureW to
 - isFailed
```
public boolean isFailed()
```
 Returns:
 
 true if this FutureW 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> FutureW<T> unit(T unit)
```
 Specified by:
 
 unit in interface MonadicValue<T>
 
 Specified by:
 
 unit in interface MonadicValue1<T>
 
 Specified by:
 
 unit in interface Unit<T>
 - stream
```
public ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface Foldable<T>
 
 Specified by:
 
 stream in interface Value<T>
 
 Returns:
 
 this Foldable converted to a Stream (ReactiveSeq) of it's elements
 - flatten
```
public <R> FutureW<R> flatten()
```
 Specified by:
 
 flatten in interface FlatMap<T>
 - flatMap
```
public <R> FutureW<R> flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends R>> mapper)
```
 Description copied from interface: MonadicValue1
 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 MonadicValue1<T>
 
 Parameters:
 
 mapper - transformation function
 
 Returns:
 
 MonadicValue
 - flatMapCf
```
public <R> FutureW<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 FutureW
 - 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
 - toFutureW
```
public FutureW<T> toFutureW()
```
 Specified by:
 
 toFutureW in interface Convertable<T>
 
 Returns:
 
 This convertable converted to a FutureW
 - 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 FutureW<T> recover(java.util.function.Function<java.lang.Throwable,? extends T> fn)
```
 Returns a new FutureW that, when this FutureW completes exceptionally is executed with this FutureW exception as the argument to the supplied function. Otherwise, if this FutureW completes normally, then the returned FutureW also completes normally with the same value.
```
 
 FutureW.ofError(new RuntimeException())
 .recover(__ -> true)
 
 //FutureW[true]
 
 
 
```
 Parameters:
 
 fn - the function to use to compute the value of the returned FutureW if this FutureW completed exceptionally
 
 Returns:
 
 the new FutureW
 - map
```
public <R> FutureW<R> map(java.util.function.Function<? super T,R> success,
 java.util.function.Function<java.lang.Throwable,R> failure)
```
 Map this FutureW differently depending on whether the previous stage completed successfully or failed
```
 
 FutureW.ofResult(1)
 .map(i->i*2,e->-1);
 //FutureW[2]
 
 
```
 Parameters:
 
 success - Mapping function for successful outcomes
 
 failure - Mapping function for failed outcomes
 
 Returns:
 
 New futureW mapped to a new state
 - cast
```
public  FutureW cast(java.lang.Class<? extends U> type)
```
 Description copied from interface: Functor
 
 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 Functor<T>
 - peek
```
public FutureW<T> peek(java.util.function.Consumer<? super T> c)
```
 Description copied from interface: Functor
 Peek at the current value of this Functor, without transforming it
```
 
 
 
 of(1,2,3).map(System.out::println)
 
 1
 2
 3
 
 
 
```
 Specified by:
 
 peek in interface Functor<T>
 
 Parameters:
 
 c - Consumer that recieves each element from this Functor
 
 Returns:
 
 Functor that will peek at each value
 - trampoline
```
public <R> FutureW<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
```
 Description copied from interface: Functor
 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 Functor<T>
 
 Parameters:
 
 mapper - TCO Transformation function
 
 Returns:
 
 Functor transformed by the supplied transformation function
 - toString
```
public java.lang.String toString()
```
 Overrides:
 
 toString in class java.lang.Object
 - ofResult
```
public static <T> FutureW<T> ofResult(T result)
```
 Construct a successfully completed FutureW from the given value
 
 Parameters:
 
 result - To wrap inside a FutureW
 
 Returns:
 
 FutureW containing supplied result
 - ofError
```
public static <T> FutureW<T> ofError(java.lang.Throwable error)
```
 Construct a completed-with-error FutureW from the given Exception
 
 Parameters:
 
 error - To wrap inside a FutureW
 
 Returns:
 
 FutureW 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: Filterable
 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 Filterable<T>
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - ofType
```
public  Maybe ofType(java.lang.Class<? extends U> type)
```
 Description copied from interface: Filterable
 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 Filterable<T>
 - filterNot
```
public Maybe<T> filterNot(java.util.function.Predicate<? super T> fn)
```
 Description copied from interface: Filterable
 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 Filterable<T>
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - notNull
```
public Maybe<T> notNull()
```
 Description copied from interface: Filterable
 Filter elements retaining only values which are not null
```
 
 
 of(1,2,null,4).nonNull();
 
 //[1,2,4]
 
 
 
```
 Specified by:
 
 notNull in interface Filterable<T>
 
 Returns:
 
 Filterable 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 FutureW<T> toFutureWAsync()
```
 Specified by:
 
 toFutureWAsync in interface Convertable<T>
 
 Returns:
 
 This convertable converted to a FutureW asyncrhonously
 - toFutureWAsync
```
public FutureW<T> toFutureWAsync(java.util.concurrent.Executor ex)
```
 Description copied from interface: Convertable
 
 This convertable converted to a FutureW 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 FutureW asyncrhonously
 - combine
```
public <T2,R> FutureW<R> combine(Value<? extends T2> app,
 java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
```
 Description copied from interface: Combiner
 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 Combiner<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> FutureW<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 ApplicativeFunctor<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 app - to zip with
 
 fn - Zip function
 
 Returns:
 
 Combined zippable
 - zip
```
public <T2,R> FutureW<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 ApplicativeFunctor<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 fn - Zip / combining function
 
 app - to combine with
 
 Returns:
 
 Combined zippable
 - ofSupplier
```
public static <T> FutureW<T> ofSupplier(java.util.function.Supplier<T> s)
```
 Create a FutureW object that asyncrhonously populates using the Common ForkJoinPool from the user provided Supplier
 
 Parameters:
 
 s - Supplier to asynchronously populate results from
 
 Returns:
 
 FutureW asynchronously populated from the Supplier
 - ofSupplier
```
public static <T> FutureW<T> ofSupplier(java.util.function.Supplier<T> s,
 java.util.concurrent.Executor ex)
```
 Create a FutureW 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:
 
 FutureW asynchronously populated from the Supplier
 - zip
```
public <U,R> FutureW<R> zip(org.jooq.lambda.Seq<? 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 Seq, using the supplied combining function
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Seq to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zip
```
public <U,R> FutureW<R> zip(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:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zip
```
public  FutureW<org.jooq.lambda.tuple.Tuple2<T,U>> zip(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:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - zip
```
public  FutureW<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Seq to combine with
 
 Returns:
 
 Combined Zippable
 - zip
```
public  FutureW<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:
 - flatMapIterable
```
public <R> FutureW<R> flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
```
 Description copied from interface: MonadicValue1
 A flattening transformation operation that takes the first value from the returned Iterable.
```
 
 Maybe.just(1).map(i->i+2).flatMapIterable(i->Arrays.asList(()->i*3,20);
 //Maybe[9]
 
 
```
 Specified by:
 
 flatMapIterable in interface MonadicValue1<T>
 
 Parameters:
 
 mapper - transformation function
 
 Returns:
 
 MonadicValue
 - flatMapPublisher
```
public <R> FutureW<R> flatMapPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
```
 Description copied from interface: MonadicValue1
 A flattening transformation operation that takes the first value from the returned Publisher.
```
 
 FutureW.ofResult(1).map(i->i+2).flatMapPublisher(i->Flux.just(()->i*3,20);
 //FutureW[9]
 
 
```
 Specified by:
 
 flatMapPublisher in interface MonadicValue1<T>
 
 Parameters:
 
 mapper - transformation function
 
 Returns:
 
 MonadicValue
 - combine
```
public FutureW<T> combine(java.util.function.BinaryOperator<Combiner<T>> combiner,
 Combiner<T> app)
```
 Description copied from interface: Combiner
 
 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:
 
 combine in interface Combiner<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.cyclops.Semigroups#combineApplicatives(BiFunction) } or Monoids { {@see com.aol.cyclops.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops.Monoid) } {@code BinaryOperator> sumMaybes = Semigroups.combineScalarFunctors(Semigroups.intSum); Maybe.just(1) .combine(sumMaybes, Maybe.just(5)) //Maybe.just(6)); }

Class FutureW<T>

Nested Class Summary

Nested classes/interfaces inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor

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

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor

Methods inherited from interface com.aol.cyclops.types.MonadicValue1

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

Methods inherited from interface com.aol.cyclops.types.Foldable

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

Methods inherited from interface java.util.function.Predicate

Methods inherited from interface java.lang.Iterable

Constructor Detail

FutureW

Method Detail

empty

future

anyOf

allOf

quorum

firstSuccess

completeExceptionally

fromPublisher

fromIterable

fromPublisher

fromIterable

of

fromTry

fromTry

schedule

schedule

sequence

sequence

accumulateSuccess

accumulate

accumulateSuccess

accumulateSuccess

accumulate

accumulate

matches

coflatMap

nest

combineEager

map

map

patternMatch

get

isSuccess

isDone

isCancelled

cancel

complete

isFailed

iterator

unit

stream

flatten

flatMap

flatMapCf

toXor

toIor

toFutureW

toCompletableFuture

toCompletableFutureAsync

toCompletableFutureAsync

recover

map

cast

peek

trampoline

toString

ofResult

ofError

isPresent

mkString

filter