EagerFutureStream (simple-react 0.4 API)

All Superinterfaces:

java.lang.AutoCloseable, java.util.stream.BaseStream<U,java.util.stream.Stream>, BlockingStream, ConfigurableStream, EagerOrLazyToQueue, EagerToQueue, FutureStream, java.lang.Iterable, LazyStream, LazyToQueue, org.jooq.lambda.Seq, SimpleReactStream, java.util.stream.Stream, ToQueue

All Known Implementing Classes:

EagerFutureStreamImpl
```
public interface EagerFutureStream
extends FutureStream, EagerToQueue
```
Static Factory methods for Simple React Flows

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.stream.Stream
 java.util.stream.Stream.Builder<T>

Field Summary
- Fields inherited from interface com.aol.simple.react.stream.traits.BlockingStream
  exceptionSoftener

Method Summary

All Methods Static Methods Instance Methods Default Methods
Modifier and Type	Method and Description
`default <T,R> EagerFutureStream<R>`	`allOf(java.util.stream.Collector collector, java.util.function.Function<T,R> fn)`
`default <T,R> EagerFutureStream<R>`	`allOf(java.util.function.Function<java.util.List<T>,R> fn)` React and allOf allOf is a non-blocking equivalent of block.
`default EagerFutureStream<U>`	`capture(java.util.function.Consumer<? extends java.lang.Throwable> errorHandler)` React capture While onFail is used for disaster recovery (when it is possible to recover) - capture is used to capture those occasions where the full pipeline has failed and is unrecoverable.
`default <U> EagerFutureStream<U>`	`cast(java.lang.Class<U> type)`
`default FutureStream<U>`	`concat(SimpleReactStream<U> other)`
`default EagerFutureStream<U>`	`concat(java.util.stream.Stream<U> other)` Concatenate two streams.
`default EagerFutureStream<U>`	`concat(U... other)` Concatenate two streams.
`default EagerFutureStream<U>`	`concat(U other)` Concatenate two streams.
`default EagerFutureStream<U>`	`distinct()`
`default org.jooq.lambda.tuple.Tuple2<org.jooq.lambda.Seq<U>,org.jooq.lambda.Seq<U>>`	`duplicate()` Duplicate a Streams into two equivalent Streams.
`default org.jooq.lambda.tuple.Tuple2<EagerFutureStream<U>,EagerFutureStream<U>>`	`duplicateFutureStream()` Duplicate a Stream into two equivalent EagerFutureStreams EagerFutureStream.of(1, 2, 3).duplicate() results in tuple((1,2,3),(1,2,3))
`static EagerReact`	`eagerBuilder(java.util.concurrent.ExecutorService executor)`
`static EagerReact`	`eagerBuilder(java.util.concurrent.ExecutorService executor, com.nurkiewicz.asyncretry.RetryExecutor retry)`
`static EagerReact`	`eagerBuilder(com.nurkiewicz.asyncretry.RetryExecutor retry)`
`static <T> EagerFutureStream<T>`	`empty()`
`default EagerFutureStream<U>`	`filter(java.util.function.Predicate<? super U> p)` Removes elements that do not match the supplied predicate from the dataflow
`default <R> EagerFutureStream<R>`	`flatMap(java.util.function.Function<? super U,? extends java.util.stream.Stream<? extends R>> flatFn)` Allows aggregate values in a Stream to be flatten into a single Stream.
`default <R> EagerFutureStream<R>`	`fromStream(java.util.stream.Stream<R> stream)`
`default <R> EagerFutureStream<R>`	`fromStreamCompletableFuture(java.util.stream.Stream<java.util.concurrent.CompletableFuture<R>> stream)` Construct a SimpleReactStream from provided Stream of CompletableFutures
`static <T> EagerFutureStream<T>`	`futureStream(java.lang.Iterable<T> iterable)` Wrap an Iterable into a FutureStream.
`static <T> EagerFutureStream<T>`	`futureStream(java.util.Iterator<T> iterator)` Wrap an Iterator into a FutureStream.
`static <T> EagerFutureStream<T>`	`futureStream(java.util.stream.Stream<T> stream)` Wrap a Stream into a FutureStream.
`default EagerFutureStream<U>`	`intersperse(U value)` Returns a stream with a given value interspersed between any two values of this stream.
`default EagerFutureStream<U>`	`limit(long maxSize)`
`default EagerFutureStream<U>`	`limitUntil(java.util.function.Predicate<? super U> predicate)` Returns a stream limited to all elements for which a predicate evaluates to false.
`default EagerFutureStream<U>`	`limitWhile(java.util.function.Predicate<? super U> predicate)` Returns a stream limited to all elements for which a predicate evaluates to true.
`default EagerFutureStream<U>`	`merge(SimpleReactStream<U> s)` Merge this reactive dataflow with another of the same type.
`static <T> EagerFutureStream<T>`	`of(T... values)`
`static <T> EagerFutureStream<T>`	`of(T value)`
`default <U> EagerFutureStream<U>`	`ofType(java.lang.Class<U> type)` Keep only those elements in a stream that are of a given type.
`default <U> EagerFutureStream<U>`	`onFail(java.util.function.Function<? extends SimpleReactFailedStageException,U> fn)` React onFail Define a function that can be used to recover from exceptions during the preceeding stage of the dataflow.
`static EagerReact`	`paraellelCommonBuilder()`
`static <U> EagerFutureStream<U>`	`parallel(U... array)` Construct an Eager SimpleReact Stream from specified array
`static EagerReact`	`parallelBuilder()`
`static EagerReact`	`parallelBuilder(int parallelism)` Construct a new EagerReact builder, with a new task executor and retry executor with configured number of threads
`default org.jooq.lambda.tuple.Tuple2<org.jooq.lambda.Seq<U>,org.jooq.lambda.Seq<U>>`	`partition(java.util.function.Predicate<? super U> predicate)` Partition a stream into two given a predicate.
`default org.jooq.lambda.tuple.Tuple2<EagerFutureStream<U>,EagerFutureStream<U>>`	`partitionFutureStream(java.util.function.Predicate<? super U> predicate)` Partition an EagerFutureStream into two EagerFutureStreams given a predicate.
`default EagerFutureStream<U>`	`peek(java.util.function.Consumer<? super U> consumer)` Peek asynchronously at the results in the current stage.
`default <R> EagerFutureStream<R>`	`retry(java.util.function.Function<U,R> fn)` Will execute this phase on the RetryExecutor (default or user supplied).
`default EagerFutureStream<U>`	`reverse()` Reverse a stream.
`default <T> EagerFutureStream<T>`	`scanLeft(T seed, java.util.function.BiFunction<T,? super U,T> function)` Scan a stream to the left.
`default <R> EagerFutureStream<R>`	`scanRight(R seed, java.util.function.BiFunction<? super U,R,R> function)` Scan a stream to the right.
`static EagerReact`	`sequentialBuilder()`
`static EagerReact`	`sequentialCommonBuilder()`
`default EagerFutureStream<U>`	`shuffle()` Shuffle a stream // e.g.
`default EagerFutureStream<U>`	`shuffle(java.util.Random random)` Shuffle a stream using specified source of randomness // e.g.
`default EagerFutureStream<U>`	`skip(long n)`
`default EagerFutureStream<U>`	`skipUntil(java.util.function.Predicate<? super U> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to false.
`default EagerFutureStream<U>`	`skipWhile(java.util.function.Predicate<? super U> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to true.
`default EagerFutureStream<U>`	`slice(long from, long to)` Returns a limited interval from a given Stream.
`default org.jooq.lambda.tuple.Tuple2<org.jooq.lambda.Seq<U>,org.jooq.lambda.Seq<U>>`	`splitAt(long position)` Split a stream at a given position.
`default org.jooq.lambda.tuple.Tuple2<EagerFutureStream<U>,EagerFutureStream<U>>`	`splitAtFutureStream(long position)` Split a EagerFutureStream at a given position.
`default org.jooq.lambda.tuple.Tuple2<java.util.Optional<U>,org.jooq.lambda.Seq<U>>`	`splitAtHead()` Split a stream at the head.
`default org.jooq.lambda.tuple.Tuple2<java.util.Optional<U>,EagerFutureStream<U>>`	`splitAtHeadFutureStream()` SplitAtHead but return type is EagerFutureStream
`default <R> EagerFutureStream<R>`	`then(java.util.function.Function<U,R> fn)` React then Unlike 'with' this method is fluent, and returns another Stage Builder that can represent the next stage in the dataflow.
`default <R> EagerFutureStream<org.jooq.lambda.tuple.Tuple2<U,R>>`	`zip(org.jooq.lambda.Seq<R> other)` Zip two streams into one.
`default <T,R> EagerFutureStream<R>`	`zip(org.jooq.lambda.Seq<T> other, java.util.function.BiFunction<U,T,R> zipper)` Zip two streams into one using a `BiFunction` to produce resulting values.
`default EagerFutureStream<org.jooq.lambda.tuple.Tuple2<U,java.lang.Long>>`	`zipWithIndex()` Zip a Stream with a corresponding Stream of indexes.

Methods inherited from interface com.aol.simple.react.stream.traits.FutureStream
allMatch, anyMatch, cast, close, collect, count, findAny, findFirst, flatMapToDouble, flatMapToInt, flatMapToLong, forEach, forEachOrdered, intersperse, isParallel, iterator, map, mapToDouble, mapToInt, mapToLong, max, merge, min, noneMatch, ofType, onClose, parallel, reduce, reduce, reduce, self, sequential, slice, sorted, sorted, spliterator, stream, toArray, toArray, unordered

Methods inherited from interface org.jooq.lambda.Seq
cast, concat, cycle, cycle, duplicate, foldLeft, foldLeft, foldRight, foldRight, generate, generate, generate, groupBy, groupBy, groupBy, groupBy, groupBy, groupBy, intersperse, iterate, join, join, join, join, join, join, limit, limitUntil, limitWhile, maxBy, maxBy, minBy, minBy, ofType, partition, reverse, scanLeft, scanRight, seq, seq, seq, seq, seq, shuffle, shuffle, skip, skipUntil, skipWhile, slice, splitAt, splitAtHead, toCollection, toCollection, toList, toList, toMap, toMap, toMap, toSet, toSet, toString, toString, toString, unfold, unzip, unzip, unzip, unzip, zip, zip, zipWithIndex

Methods inherited from interface java.util.stream.Stream
builder, collect, concat

Methods inherited from interface com.aol.simple.react.stream.traits.SimpleReactStream
assureSimpleReactException, futureStream, handleExceptions, lastActiveArray, merge, parallelCommonBuilder, parallelOf, simple, simple, simple, streamCompletableFutures, with

Methods inherited from interface com.aol.simple.react.stream.traits.LazyStream
getLastActive, getLazyCollector, getWaitStrategy, run, run, run, run, runOnCurrent

Methods inherited from interface com.aol.simple.react.stream.traits.BlockingStream
aggregateResults, block, block, block, block, block, blockAndExtract, blockAndExtract, capture, collectResults, first, getSafe, last, submitAndBlock

Methods inherited from interface com.aol.simple.react.stream.traits.ConfigurableStream
getErrorHandler, getLastActive, getRetrier, getSimpleReact, getTaskExecutor, isEager, withEager, withErrorHandler, withLastActive, withLazyCollector, withQueueFactory, withRetrier, withTaskExecutor, withWaitStrategy

Methods inherited from interface com.aol.simple.react.stream.traits.EagerOrLazyToQueue
isEager, toQueue

Methods inherited from interface com.aol.simple.react.stream.traits.EagerToQueue
getQueueFactory

Methods inherited from interface com.aol.simple.react.stream.traits.LazyToQueue
getQueueFactory

- Method Detail
 - then
```
default <R> EagerFutureStream<R> then(java.util.function.Function<U,R> fn)
```
 Description copied from interface: SimpleReactStream
 
 React then Unlike 'with' this method is fluent, and returns another Stage Builder that can represent the next stage in the dataflow. new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3) .then((it) -> it * 100) .then((it) -> "*" + it) React then allows event reactors to be chained. Unlike React with, which returns a collection of Future references, React then is a fluent interface that returns the React builder - allowing further reactors to be added to the chain. React then does not block. React with can be called after React then which gives access to the full CompleteableFuture api. CompleteableFutures can be passed back into SimpleReact via SimpleReact.react(streamOfCompleteableFutures); See this blog post for examples of what can be achieved via CompleteableFuture :- http://www.nurkiewicz.com/2013/12/promises-and-completablefuture.htm l
 
 Specified by:
 
 then in interface EagerToQueue
 
 Specified by:
 
 then in interface FutureStream
 
 Specified by:
 
 then in interface LazyToQueue
 
 Specified by:
 
 then in interface SimpleReactStream
 
 Parameters:
 
 fn - Function to be applied to the results of the currently active event tasks
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - merge
```
default EagerFutureStream merge(SimpleReactStream s)
```
 Description copied from interface: SimpleReactStream
 
 Merge this reactive dataflow with another of the same type. To merge flows of different types use the static method merge and merge to a common ancestor.
 
 Specified by:
 
 merge in interface FutureStream
 
 Specified by:
 
 merge in interface SimpleReactStream
 
 Parameters:
 
 s - Reactive stage builder to merge with
 
 Returns:
 
 Merged dataflow
 - onFail
```
default  EagerFutureStream onFail(java.util.function.Function<? extends SimpleReactFailedStageException,U> fn)
```
 Description copied from interface: SimpleReactStream
 
 React onFail Define a function that can be used to recover from exceptions during the preceeding stage of the dataflow. e.g. onFail allows disaster recovery for each task (a separate onFail should be configured for each react phase that can fail). E.g. if reading data from an external service fails, but default value is acceptable - onFail is a suitable mechanism to set the default value. Asynchronously apply the function supplied to the currently active event tasks in the dataflow. List<String> strings = new SimpleReact().<Integer, Integer> react(() -> 100, () -> 2, () -> 3) .then(it -> { if (it == 100) throw new RuntimeException("boo!"); return it; }) .onFail(e -> 1) .then(it -> "*" + it) .block(); In this example onFail recovers from the RuntimeException thrown when the input to the first 'then' stage is 100.
 
 Specified by:
 
 onFail in interface FutureStream
 
 Specified by:
 
 onFail in interface SimpleReactStream
 
 Parameters:
 
 fn - Recovery function, the exception is input, and the recovery value is output
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - capture
```
default EagerFutureStream capture(java.util.function.Consumer<? extends java.lang.Throwable> errorHandler)
```
 Description copied from interface: SimpleReactStream
 
 React capture While onFail is used for disaster recovery (when it is possible to recover) - capture is used to capture those occasions where the full pipeline has failed and is unrecoverable. List<String> strings = new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3) .then(it -> it * 100) .then(it -> { if (it == 100) throw new RuntimeException("boo!"); return it; }) .onFail(e -> 1) .then(it -> "*" + it) .then(it -> { if ("*200".equals(it)) throw new RuntimeException("boo!"); return it; }) .capture(e -> logger.error(e.getMessage(),e)) .block(); In this case, strings will only contain the two successful results (for ()->1 and ()->3), an exception for the chain starting from Supplier ()->2 will be logged by capture. Capture will not capture the exception thrown when an Integer value of 100 is found, but will catch the exception when the String value "*200" is passed along the chain.
 
 Specified by:
 
 capture in interface FutureStream
 
 Specified by:
 
 capture in interface SimpleReactStream
 
 Parameters:
 
 errorHandler - A consumer that recieves and deals with an unrecoverable error in the dataflow
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - allOf
```
default <T,R> EagerFutureStream<R> allOf(java.util.function.Function<java.util.List<T>,R> fn)
```
 Description copied from interface: SimpleReactStream
 
 React and allOf allOf is a non-blocking equivalent of block. The current thread is not impacted by the calculations, but the reactive chain does not continue until all currently alloted tasks complete. The allOf task is then provided with a list of the results from the previous tasks in the chain. boolean blocked[] = {false}; new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3) .then(it -> { try { Thread.sleep(50000); } catch (Exception e) { } blocked[0] =true; return 10; }) .allOf( it -> it.size()); assertThat(blocked[0],is(false)); In this example, the current thread will continue and assert that it is not blocked, allOf could continue and be executed in a separate thread.
 
 Specified by:
 
 allOf in interface FutureStream
 
 Specified by:
 
 allOf in interface SimpleReactStream
 
 Parameters:
 
 fn - Function that recieves the results of all currently active tasks as input
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - peek
```
default EagerFutureStream peek(java.util.function.Consumer<? super U> consumer)
```
 Description copied from interface: SimpleReactStream
 
 Peek asynchronously at the results in the current stage. Current results are passed through to the next stage.
 
 Specified by:
 
 peek in interface FutureStream
 
 Specified by:
 
 peek in interface org.jooq.lambda.Seq
 
 Specified by:
 
 peek in interface SimpleReactStream
 
 Specified by:
 
 peek in interface java.util.stream.Stream
 
 Parameters:
 
 consumer - That will recieve current results
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - filter
```
default EagerFutureStream filter(java.util.function.Predicate<? super U> p)
```
 Description copied from interface: SimpleReactStream
 
 Removes elements that do not match the supplied predicate from the dataflow
 
 Specified by:
 
 filter in interface FutureStream
 
 Specified by:
 
 filter in interface org.jooq.lambda.Seq
 
 Specified by:
 
 filter in interface SimpleReactStream
 
 Specified by:
 
 filter in interface java.util.stream.Stream
 
 Parameters:
 
 p - Predicate that will be used to filter elements from the dataflow
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - flatMap
```
default <R> EagerFutureStream<R> flatMap(java.util.function.Function<? super U,? extends java.util.stream.Stream<? extends R>> flatFn)
```
 Description copied from interface: SimpleReactStream
 
 Allows aggregate values in a Stream to be flatten into a single Stream. flatMap functions turn each aggregate value into it's own Stream, and SimpleReact aggregates those Streams into a single flattened stream
 
 Specified by:
 
 flatMap in interface FutureStream
 
 Specified by:
 
 flatMap in interface org.jooq.lambda.Seq
 
 Specified by:
 
 flatMap in interface SimpleReactStream
 
 Specified by:
 
 flatMap in interface java.util.stream.Stream
 
 Parameters:
 
 flatFn - Function that coverts a value (e.g. a Collection) into a Stream
 
 Returns:
 
 SimpleReactStream
 - retry
```
default <R> EagerFutureStream<R> retry(java.util.function.Function<U,R> fn)
```
 Description copied from interface: SimpleReactStream
 
 Will execute this phase on the RetryExecutor (default or user supplied). The RetryExecutor can be changed via withRetrier. This stage will be retried according to the configured rules. See https://github.com/nurkiewicz/async-retry for detailed advice on how to conifugre
 
 Specified by:
 
 retry in interface FutureStream
 
 Specified by:
 
 retry in interface SimpleReactStream
 
 Parameters:
 
 fn - Function that will be executed and retried on failure
 
 Returns:
 
 Next Stage in the Strea,
 - allOf
```
default <T,R> EagerFutureStream<R> allOf(java.util.stream.Collector collector,
 java.util.function.Function<T,R> fn)
```
 Specified by:
 
 allOf in interface EagerToQueue
 
 Specified by:
 
 allOf in interface FutureStream
 
 Specified by:
 
 allOf in interface LazyToQueue
 
 Specified by:
 
 allOf in interface SimpleReactStream
 
 Parameters:
 
 collector - to perform aggregation / reduction operation on the results from active stage (e.g. to Collect into a List or String)
 
 fn - Function that receives the results of all currently active tasks as input
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - fromStream
```
default <R> EagerFutureStream<R> fromStream(java.util.stream.Stream<R> stream)
```
 Specified by:
 
 fromStream in interface FutureStream
 
 Specified by:
 
 fromStream in interface SimpleReactStream
 - fromStreamCompletableFuture
```
default <R> EagerFutureStream<R> fromStreamCompletableFuture(java.util.stream.Stream<java.util.concurrent.CompletableFuture<R>> stream)
```
 Description copied from interface: SimpleReactStream
 
 Construct a SimpleReactStream from provided Stream of CompletableFutures
 
 Specified by:
 
 fromStreamCompletableFuture in interface FutureStream
 
 Specified by:
 
 fromStreamCompletableFuture in interface SimpleReactStream
 
 Parameters:
 
 stream - JDK Stream to construct new SimpleReactStream from
 
 Returns:
 
 SimpleReactStream
 - limit
```
default EagerFutureStream limit(long maxSize)
```
 Specified by:
 
 limit in interface org.jooq.lambda.Seq
 
 Specified by:
 
 limit in interface java.util.stream.Stream
 - cast
```
default  EagerFutureStream cast(java.lang.Class type)
```
 Specified by:
 
 cast in interface FutureStream
 
 Specified by:
 
 cast in interface org.jooq.lambda.Seq
 - ofType
```
default  EagerFutureStream ofType(java.lang.Class type)
```
 Keep only those elements in a stream that are of a given type. EagerFutureStream.of(1, "a", 2, "b", 3).ofType(Integer.class) gives a Stream of (1,2,3) EagerFutureStream.of(1, "a", 2, "b", 3).ofType(String.class) gives a Stream of ("a","b")
 
 Specified by:
 
 ofType in interface FutureStream
 
 Specified by:
 
 ofType in interface org.jooq.lambda.Seq
 
 See Also:
 
 FutureStream.ofType(java.lang.Class)
 - skip
```
default EagerFutureStream skip(long n)
```
 Specified by:
 
 skip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 skip in interface java.util.stream.Stream
 - concat
```
default EagerFutureStream concat(java.util.stream.Stream other)
```
 Concatenate two streams. // (1, 2, 3, 4, 5, 6) EagerFutureStream.of(1, 2, 3).concat(EagerFutureStream.of(4, 5, 6))
 
 Specified by:
 
 concat in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.concat(Stream[])
 - concat
```
default FutureStream concat(SimpleReactStream other)
```
 - concat
```
default EagerFutureStream concat(U other)
```
 Concatenate two streams. // (1, 2, 3, 4) EagerFutureStream.of(1, 2, 3).concat(4)
 
 Specified by:
 
 concat in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.concat(Stream[])
 - concat
```
default EagerFutureStream concat(U... other)
```
 Concatenate two streams. // (1, 2, 3, 4, 5, 6) EagerFutureStream.of(1, 2, 3).concat(4, 5, 6)
 
 Specified by:
 
 concat in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.concat(Stream[])
 - slice
```
default EagerFutureStream slice(long from,
 long to)
```
 Returns a limited interval from a given Stream. // (4, 5) EagerFutureStream.of(1, 2, 3, 4, 5, 6).slice(3, 5)
 
 Specified by:
 
 slice in interface FutureStream
 
 Specified by:
 
 slice in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.slice(Stream, long, long)
 - zip
```
default <R> EagerFutureStream<org.jooq.lambda.tuple.Tuple2<U,R>> zip(org.jooq.lambda.Seq<R> other)
```
 Zip two streams into one. // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c")) EagerFutureStream.of(1, 2, 3).zip(EagerFutureStream.of("a", "b", "c"))
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.zip(Stream, Stream)
 - zip
```
default <T,R> EagerFutureStream<R> zip(org.jooq.lambda.Seq<T> other,
 java.util.function.BiFunction<U,T,R> zipper)
```
 Zip two streams into one using a BiFunction to produce resulting values. // ("1:a", "2:b", "3:c") EagerFutureStream.of(1, 2, 3).zip(EagerFutureStream.of("a", "b", "c"), (i, s) > i + ":" + s)
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 See Also:
 
 zip(Seq, BiFunction)
 - zipWithIndex
```
default EagerFutureStream<org.jooq.lambda.tuple.Tuple2<U,java.lang.Long>> zipWithIndex()
```
 Zip a Stream with a corresponding Stream of indexes. // (tuple("a", 0), tuple("b", 1), tuple("c", 2)) EagerFutureStream.of("a", "b", "c").zipWithIndex()
 
 Specified by:
 
 zipWithIndex in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.zipWithIndex(Stream)
 - scanLeft
```
default <T> EagerFutureStream<T> scanLeft(T seed,
 java.util.function.BiFunction<T,? super U,T> function)
```
 Scan a stream to the left. // ("", "a", "ab", "abc") EagerFutureStream.of("a", "b", "c").scanLeft("", (u, t) > u + t)
 
 Specified by:
 
 scanLeft in interface org.jooq.lambda.Seq
 - scanRight
```
default <R> EagerFutureStream<R> scanRight(R seed,
 java.util.function.BiFunction<? super U,R,R> function)
```
 Scan a stream to the right. // ("", "c", "cb", "cba") EagerFutureStream.of("a", "b", "c").scanRight("", (t, u) > u + t)
 
 Specified by:
 
 scanRight in interface org.jooq.lambda.Seq
 - reverse
```
default EagerFutureStream reverse()
```
 Reverse a stream. // (3, 2, 1) EagerFutureStream.of(1, 2, 3).reverse()
 
 Specified by:
 
 reverse in interface org.jooq.lambda.Seq
 - shuffle
```
default EagerFutureStream shuffle()
```
 Shuffle a stream // e.g. (2, 3, 1) EagerFutureStream.of(1, 2, 3).shuffle()
 
 Specified by:
 
 shuffle in interface org.jooq.lambda.Seq
 - shuffle
```
default EagerFutureStream shuffle(java.util.Random random)
```
 Shuffle a stream using specified source of randomness // e.g. (2, 3, 1) EagerFutureStream.of(1, 2, 3).shuffle(new Random())
 
 Specified by:
 
 shuffle in interface org.jooq.lambda.Seq
 - skipWhile
```
default EagerFutureStream skipWhile(java.util.function.Predicate<? super U> predicate)
```
 Returns a stream with all elements skipped for which a predicate evaluates to true. // (3, 4, 5) EagerFutureStream.of(1, 2, 3, 4, 5).skipWhile(i > i < 3)
 
 Specified by:
 
 skipWhile in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.skipWhile(Stream, Predicate)
 - skipUntil
```
default EagerFutureStream skipUntil(java.util.function.Predicate<? super U> predicate)
```
 Returns a stream with all elements skipped for which a predicate evaluates to false. // (3, 4, 5) EagerFutureStream.of(1, 2, 3, 4, 5).skipUntil(i > i == 3)
 
 Specified by:
 
 skipUntil in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.skipUntil(Stream, Predicate)
 - limitWhile
```
default EagerFutureStream limitWhile(java.util.function.Predicate<? super U> predicate)
```
 Returns a stream limited to all elements for which a predicate evaluates to true. // (1, 2) EagerFutureStream.of(1, 2, 3, 4, 5).limitWhile(i -> i < 3)
 
 Specified by:
 
 limitWhile in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.limitWhile(Stream, Predicate)
 - limitUntil
```
default EagerFutureStream limitUntil(java.util.function.Predicate<? super U> predicate)
```
 Returns a stream limited to all elements for which a predicate evaluates to false. // (1, 2) EagerFutureStream.of(1, 2, 3, 4, 5).limitUntil(i > i == 3)
 
 Specified by:
 
 limitUntil in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.limitUntil(Stream, Predicate)
 - intersperse
```
default EagerFutureStream intersperse(U value)
```
 Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) EagerFutureStream.of(1, 2, 3, 4).intersperse(0)
 
 Specified by:
 
 intersperse in interface FutureStream
 
 Specified by:
 
 intersperse in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.intersperse(Stream, Object)
 - parallel
```
static  EagerFutureStream parallel(U... array)
```
 Construct an Eager SimpleReact Stream from specified array
 
 Parameters:
 
 array - Values to react to
 
 Returns:
 
 Next SimpleReact stage
 - distinct
```
default EagerFutureStream distinct()
```
 Specified by:
 
 distinct in interface org.jooq.lambda.Seq
 
 Specified by:
 
 distinct in interface java.util.stream.Stream
 - duplicate
```
default org.jooq.lambda.tuple.Tuple2<org.jooq.lambda.Seq,org.jooq.lambda.Seq> duplicate()
```
 Duplicate a Streams into two equivalent Streams. // tuple((1, 2, 3), (1, 2, 3)) EagerFutureStream.of(1, 2, 3).duplicate()
 
 Specified by:
 
 duplicate in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.duplicate(Stream)
 - duplicateFutureStream
```
default org.jooq.lambda.tuple.Tuple2<EagerFutureStream,EagerFutureStream> duplicateFutureStream()
```
 Duplicate a Stream into two equivalent EagerFutureStreams EagerFutureStream.of(1, 2, 3).duplicate() results in tuple((1,2,3),(1,2,3))
 
 Returns:
 
 See Also:
 
 duplicate()
 - partition
```
default org.jooq.lambda.tuple.Tuple2<org.jooq.lambda.Seq,org.jooq.lambda.Seq> partition(java.util.function.Predicate<? super U> predicate)
```
 Partition a stream into two given a predicate. // tuple((1, 3, 5), (2, 4, 6)) EagerFutureStream.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0)
 
 Specified by:
 
 partition in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.partition(Stream, Predicate)
 - partitionFutureStream
```
default org.jooq.lambda.tuple.Tuple2<EagerFutureStream,EagerFutureStream> partitionFutureStream(java.util.function.Predicate<? super U> predicate)
```
 Partition an EagerFutureStream into two EagerFutureStreams given a predicate. EagerFutureStream.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0) results in tuple((1, 3, 5), (2, 4, 6))
 
 Parameters:
 
 predicate - Predicate to split Stream
 
 Returns:
 
 EagerFutureStream
 
 See Also:
 
 partition(Predicate)
 - splitAt
```
default org.jooq.lambda.tuple.Tuple2<org.jooq.lambda.Seq,org.jooq.lambda.Seq> splitAt(long position)
```
 Split a stream at a given position. // tuple((1, 2, 3), (4, 5, 6)) EagerFutureStream.of(1, 2, 3, 4, 5, 6).splitAt(3)
 
 Specified by:
 
 splitAt in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.splitAt(Stream, long)
 - splitAtFutureStream
```
default org.jooq.lambda.tuple.Tuple2<EagerFutureStream,EagerFutureStream> splitAtFutureStream(long position)
```
 Split a EagerFutureStream at a given position. EagerFutureStream.of(1, 2, 3, 4, 5, 6).splitAt(3) results in tuple((1, 2, 3), (4, 5, 6))
 
 See Also:
 
 splitAt(long)
 - splitAtHead
```
default org.jooq.lambda.tuple.Tuple2<java.util.Optional,org.jooq.lambda.Seq> splitAtHead()
```
 Split a stream at the head. // tuple(1, (2, 3, 4, 5, 6)) EagerFutureStream.of(1, 2, 3, 4, 5, 6).splitHead(3)
 
 Specified by:
 
 splitAtHead in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.splitAt(Stream, long)
 - splitAtHeadFutureStream
```
default org.jooq.lambda.tuple.Tuple2<java.util.Optional,EagerFutureStream> splitAtHeadFutureStream()
```
 SplitAtHead but return type is EagerFutureStream
 
 Returns:
 
 See Also:
 
 splitAtHead()
 - parallelBuilder
```
static EagerReact parallelBuilder()
```
 Specified by:
 
 parallelBuilder in interface SimpleReactStream
 
 Returns:
 
 EagerReact for handling finite streams
 
 See Also:
 
 SimpleReact.SimpleReact()
 - parallelBuilder
```
static EagerReact parallelBuilder(int parallelism)
```
 Construct a new EagerReact builder, with a new task executor and retry executor with configured number of threads
 
 Specified by:
 
 parallelBuilder in interface SimpleReactStream
 
 Parameters:
 
 parallelism - Number of threads task executor should have
 
 Returns:
 
 eager EagerReact instance
 - paraellelCommonBuilder
```
static EagerReact paraellelCommonBuilder()
```
 Returns:
 
 new EagerReact builder configured with standard parallel executor By default this is the ForkJoinPool common instance but is configurable in the ThreadPools class
 
 See Also:
 
 see RetryBuilder#getDefaultInstance()
 - sequentialBuilder
```
static EagerReact sequentialBuilder()
```
 Specified by:
 
 sequentialBuilder in interface SimpleReactStream
 
 Returns:
 
 new eager EagerReact builder configured to run on a separate thread (non-blocking current thread), sequentially New ForkJoinPool will be created
 - sequentialCommonBuilder
```
static EagerReact sequentialCommonBuilder()
```
 Specified by:
 
 sequentialCommonBuilder in interface SimpleReactStream
 
 Returns:
 
 new EagerReact builder configured to run on a separate thread (non-blocking current thread), sequentially Common free thread Executor from
 - eagerBuilder
```
static EagerReact eagerBuilder(java.util.concurrent.ExecutorService executor)
```
 Parameters:
 
 executor - Executor this EagerReact instance will use to execute concurrent tasks.
 
 Returns:
 
 EagerReact for handling finite streams
 - eagerBuilder
```
static EagerReact eagerBuilder(com.nurkiewicz.asyncretry.RetryExecutor retry)
```
 Parameters:
 
 retry - RetryExecutor this SimpleReact instance will use to retry concurrent tasks.
 
 Returns:
 
 EagerReact for handling finite streams
 - eagerBuilder
```
static EagerReact eagerBuilder(java.util.concurrent.ExecutorService executor,
 com.nurkiewicz.asyncretry.RetryExecutor retry)
```
 Parameters:
 
 executor - Executor this SimpleReact instance will use to execute concurrent tasks.
 
 retry - RetryExecutor this SimpleReact instance will use to retry concurrent tasks.
 
 Returns:
 
 EagerReact for handling finite streams
 - of
```
static <T> EagerFutureStream<T> of(T value)
```
 Specified by:
 
 of in interface org.jooq.lambda.Seq
 
 Specified by:
 
 of in interface SimpleReactStream
 
 Specified by:
 
 of in interface java.util.stream.Stream
 
 See Also:
 
 Stream.of(Object)
 - of
```
@SafeVarargs
static <T> EagerFutureStream<T> of(T... values)
```
 Specified by:
 
 of in interface org.jooq.lambda.Seq
 
 Specified by:
 
 of in interface SimpleReactStream
 
 Specified by:
 
 of in interface java.util.stream.Stream
 
 See Also:
 
 Stream.of(Object[])
 - empty
```
static <T> EagerFutureStream<T> empty()
```
 Specified by:
 
 empty in interface org.jooq.lambda.Seq
 
 Specified by:
 
 empty in interface SimpleReactStream
 
 Specified by:
 
 empty in interface java.util.stream.Stream
 
 See Also:
 
 Stream.empty()
 - futureStream
```
static <T> EagerFutureStream<T> futureStream(java.util.stream.Stream<T> stream)
```
 Wrap a Stream into a FutureStream.
 
 Specified by:
 
 futureStream in interface SimpleReactStream
 - futureStream
```
static <T> EagerFutureStream<T> futureStream(java.lang.Iterable<T> iterable)
```
 Wrap an Iterable into a FutureStream.
 
 Specified by:
 
 futureStream in interface SimpleReactStream
 - futureStream
```
static <T> EagerFutureStream<T> futureStream(java.util.Iterator<T> iterator)
```
 Wrap an Iterator into a FutureStream.
 
 Specified by:
 
 futureStream in interface SimpleReactStream

Interface EagerFutureStream<U>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.stream.Stream

Field Summary

Fields inherited from interface com.aol.simple.react.stream.traits.BlockingStream

Method Summary

Methods inherited from interface com.aol.simple.react.stream.traits.FutureStream

Methods inherited from interface org.jooq.lambda.Seq

Methods inherited from interface java.util.stream.Stream

Methods inherited from interface com.aol.simple.react.stream.traits.SimpleReactStream

Methods inherited from interface com.aol.simple.react.stream.traits.LazyStream

Methods inherited from interface com.aol.simple.react.stream.traits.BlockingStream

Methods inherited from interface com.aol.simple.react.stream.traits.ConfigurableStream

Methods inherited from interface com.aol.simple.react.stream.traits.EagerOrLazyToQueue

Methods inherited from interface com.aol.simple.react.stream.traits.EagerToQueue

Methods inherited from interface com.aol.simple.react.stream.traits.LazyToQueue

Method Detail

then

merge

onFail

capture

allOf

peek

filter

flatMap

retry

allOf

fromStream

fromStreamCompletableFuture

limit

cast

ofType

skip

concat

concat

concat

concat

slice

zip

zip

zipWithIndex

scanLeft

scanRight

reverse

shuffle

shuffle

skipWhile

skipUntil

limitWhile

limitUntil

intersperse

parallel

distinct

duplicate

duplicateFutureStream

partition

partitionFutureStream

splitAt

splitAtFutureStream

splitAtHead

splitAtHeadFutureStream

parallelBuilder

parallelBuilder

paraellelCommonBuilder

sequentialBuilder

sequentialCommonBuilder

eagerBuilder

eagerBuilder

eagerBuilder

of

of

empty

futureStream

futureStream

futureStream