LazyFutureStream (simple-react 0.96 API)

All Superinterfaces:

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

All Known Implementing Classes:

LazyFutureStreamImpl
```
public interface LazyFutureStream
extends LazyStream, FutureStream, LazyToQueue
```
Lazy Stream Factory methods

Nested Class Summary
- Nested classes/interfaces inherited from interface com.aol.simple.react.stream.traits.FutureStream
 FutureStream.Val<T>
- Nested classes/interfaces inherited from interface java.util.stream.Stream
 java.util.stream.Stream.Builder<T>
- Nested classes/interfaces inherited from interface com.aol.simple.react.stream.traits.ConfigurableStream
 ConfigurableStream.SimpleReactConfigurableStream

Field Summary

Fields
Modifier and Type Field and Description

static java.lang.Object NULL
- Fields inherited from interface com.aol.simple.react.stream.traits.FutureStream
  softener

Fields
Modifier and Type	Field and Description
`static java.lang.Object`	`NULL`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <T,R> LazyFutureStream<R>`	`allOf(java.util.stream.Collector collector, java.util.function.Function<T,R> fn)`
`default <T,R> LazyFutureStream<R>`	`allOf(java.util.function.Function<java.util.List<T>,R> fn)` React and allOf allOf is a non-blocking equivalent of block.
`default <R> LazyFutureStream<R>`	`anyOf(java.util.function.Function<U,R> fn)` React to the completion of any of the events in the previous stage.
`default LazyFutureStream<U>`	`async()`
`default LazyFutureStream<java.util.Collection<U>>`	`batch(java.util.function.Function<java.util.function.Supplier<U>,java.util.function.Supplier<java.util.Collection<U>>> fn)` Batch elements into a Stream of collections with user defined function
`default LazyFutureStream<java.util.Collection<U>>`	`batchBySize(int size)` Batch the elements in this stream into Lists of specified size
`default LazyFutureStream<java.util.Collection<U>>`	`batchBySize(int size, java.util.function.Supplier<java.util.Collection<U>> supplier)` Batch the elements in this stream into Collections of specified size The type of Collection is determined by the specified supplier
`default LazyFutureStream<java.util.Collection<U>>`	`batchByTime(long time, java.util.concurrent.TimeUnit unit)` Organise elements in a Stream into a Collections based on the time period they pass through this stage
`default LazyFutureStream<java.util.Collection<U>>`	`batchByTime(long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<java.util.Collection<U>> factory)` Organise elements in a Stream into a Collections based on the time period they pass through this stage
`default LazyFutureStream<U>`	`boundedWaitFree(int size)` Use an Agrona ManyToOneConcurrentArrayQueue for the next operations (wait-free, mechanical sympathy).
`default LazyFutureStream<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> LazyFutureStream<U>`	`cast(java.lang.Class<U> type)`
`default LazyFutureStream<java.util.Collection<U>>`	`chunkSinceLastRead()`
`static void`	`close(java.util.Iterator it)`
`default void`	`closeAll()`
`default <R> R`	`collect(java.util.function.Supplier<R> supplier, java.util.function.BiConsumer<R,? super U> accumulator, java.util.function.BiConsumer<R,R> combiner)`
`default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`combineLatest(FutureStream<T> s)` Similar to zip and withLatest, except will always take the latest from either Stream (merged with last available from the other).
`default LazyFutureStream<U>`	`concat(java.util.stream.Stream<U> other)` Concatenate two streams.
`default LazyFutureStream<U>`	`control(java.util.function.Function<java.util.function.Supplier<U>,java.util.function.Supplier<U>> fn)` Allows clients to control the emission of data for the next phase of the Stream.
`default EagerFutureStream<U>`	`convertToEagerStream()` Convert between an Lazy and Eager future stream, can be used to take advantages of each approach during a single Stream
`default LazyFutureStream<U>`	`debounce(long time, java.util.concurrent.TimeUnit unit)` Can be used to debounce (accept a single data point from a unit of time) data.
`default org.jooq.lambda.Seq<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<LazyFutureStream<U>,LazyFutureStream<U>>`	`duplicateFutures()` Duplicate a Stream into two equivalent LazyFutureStreams LazyFutureStream.of(1, 2, 3).duplicate() results in tuple((1,2,3),(1,2,3)) Care should be taken not to use this method with infinite streams!
`default org.jooq.lambda.tuple.Tuple2<org.jooq.lambda.Seq<U>,org.jooq.lambda.Seq<U>>`	`duplicateFuturesSeq()` Duplicate a Stream into two equivalent Sequences LazyFutureStream.of(1, 2, 3).duplicate() results in tuple((1,2,3),(1,2,3)) Care should be taken not to use this method with infinite streams!
`static <T> LazyFutureStream<T>`	`empty()`
`default LazyFutureStream<U>`	`filter(java.util.function.Predicate<? super U> p)` Removes elements that do not match the supplied predicate from the dataflow
`default java.util.Optional<U>`	`findFirst()` Returns an `Optional` describing the first element of this stream, or an empty `Optional` if the stream is empty.
`static <U> LazyFutureStream<U>`	`firstOf(LazyFutureStream<U>... futureStreams)` Return first Stream out of provided Streams that starts emitted results
`default LazyFutureStream<U>`	`fixedDelay(long time, java.util.concurrent.TimeUnit unit)` Apply a fixed delay before emitting elements to the next phase of the Stream.
`default <R> LazyFutureStream<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 void`	`forEach(java.util.function.Consumer<? super U> c)` Stream supporting methods
`default <R> LazyFutureStream<R>`	`fromStream(java.util.stream.Stream<R> stream)`
`default <R> LazyFutureStream<R>`	`fromStreamOfFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<R>> stream)` Construct a SimpleReactStream from provided Stream of CompletableFutures
`static LazyFutureStream<java.lang.Void>`	`generate()`
`static <T> LazyFutureStream<T>`	`generate(java.util.function.Supplier<T> s)`
`static <T> LazyFutureStream<T>`	`generate(T value)`
`default LazyFutureStream<U>`	`intersperse(U value)` Returns a stream with a given value interspersed between any two values of this stream.
`static <T> LazyFutureStream<T>`	`iterate(T seed, java.util.function.UnaryOperator<T> f)`
`default LazyFutureStream<U>`	`jitter(long jitterInNanos)` Introduce a random delay between events in a stream Can be used to prevent behaviour synchronizing within a system
`default LazyFutureStream<U>`	`limit(long maxSize)`
`default LazyFutureStream<U>`	`limitUntil(java.util.function.Predicate<? super U> predicate)` Returns a stream limited to all elements for which a predicate evaluates to false.
`static <T> org.jooq.lambda.Seq<T>`	`limitUntil(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Returns a stream ed to all elements for which a predicate evaluates to `true`.
`default LazyFutureStream<U>`	`limitWhile(java.util.function.Predicate<? super U> predicate)` Returns a stream limited to all elements for which a predicate evaluates to true.
`static <T> org.jooq.lambda.Seq<T>`	`limitWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Returns a stream limited to all elements for which a predicate evaluates to `true`.
`default <R> LazyFutureStream<R>`	`map(java.util.function.Function<? super U,? extends R> mapper)`
`default LazyFutureStream<U>`	`maxActive(int concurrentTasks)` Configure the max active concurrent tasks.
`default LazyFutureStream<U>`	`merge(SimpleReactStream<U> s)` Merge this reactive dataflow with another of the same type.
`static <T> LazyFutureStream<T>`	`of(java.util.Iterator<T> iterator)` Wrap an Iterator into a FutureStream.
`static <T> LazyFutureStream<T>`	`of(java.util.stream.Stream<T> stream)` Wrap a Stream into a FutureStream.
`static <T> LazyFutureStream<T>`	`of(T... values)`
`static <T> LazyFutureStream<T>`	`of(T value)`
`static <T> LazyFutureStream<T>`	`ofIterable(java.lang.Iterable<T> iterable)` Wrap an Iterable into a FutureStream.
`default <U> FutureStream<U>`	`ofType(java.lang.Class<U> type)` Keep only those elements in a stream that are of a given type.
`default LazyFutureStream<U>`	`onClose(java.lang.Runnable closeHandler)`
`default LazyFutureStream<U>`	`onePer(long time, java.util.concurrent.TimeUnit unit)` Slow emissions down, emiting one element per specified time period
`default LazyFutureStream<U>`	`onFail(java.lang.Class<? extends java.lang.Throwable> exceptionClass, java.util.function.Function<? extends SimpleReactFailedStageException,U> fn)` Recover for a particular class of exceptions only.
`default LazyFutureStream<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.
`default LazyFutureStream<U>`	`parallel()`
`static <U> LazyFutureStream<U>`	`parallel(U... array)` Construct an Lazy SimpleReact Stream from specified array
`static LazyReact`	`parallelBuilder()`
`static LazyReact`	`parallelBuilder(int parallelism)` Construct a new LazyReact builder, with a new task executor and retry executor with configured number of threads
`static LazyReact`	`parallelCommonBuilder()`
`static <U> LazyFutureStream<U>`	`parallelOf(U... array)` Construct a SimpleReact Stage from a supplied array
`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 LazyFutureStream<U>`	`peek(java.util.function.Consumer<? super U> consumer)` Peek asynchronously at the results in the current stage.
`static <T> LazyFutureStream<T>`	`react(java.util.function.Supplier<T>... values)` Create a parallel asynchronous stream
`static <T> LazyFutureStream<T>`	`react(java.util.function.Supplier<T> value)` Create a parallel asynchronous stream
`default java.util.Optional<U>`	`reduce(java.util.function.BinaryOperator<U> accumulator)`
`default <T> T`	`reduce(T identity, java.util.function.BiFunction<T,? super U,T> accumulator, java.util.function.BinaryOperator<T> combiner)`
`default U`	`reduce(U identity, java.util.function.BinaryOperator<U> accumulator)`
`default <R> LazyFutureStream<R>`	`retry(java.util.function.Function<U,R> fn)` Will execute this phase on the RetryExecutor (default or user supplied).
`default LazyFutureStream<U>`	`reverse()` Reverse a stream.
`default <T> LazyFutureStream<T>`	`scanLeft(T seed, java.util.function.BiFunction<T,? super U,T> function)` Scan a stream to the left.
`default <R> LazyFutureStream<R>`	`scanRight(R seed, java.util.function.BiFunction<? super U,R,R> function)` Scan a stream to the right.
`default LazyFutureStream<U>`	`self(java.util.function.Consumer<FutureStream<U>> consumer)` Give a function access to the current stage of a SimpleReact Stream
`default LazyFutureStream<U>`	`sequential()`
`static LazyReact`	`sequentialBuilder()`
`static LazyReact`	`sequentialCommonBuilder()`
`default <K> java.util.Map<K,LazyFutureStream<U>>`	`shard(java.util.Map<K,Queue<U>> shards, java.util.function.Function<U,K> sharder)` Break a stream into multiple Streams based of some characteristic of the elements of the Stream e.g.
`default LazyFutureStream<U>`	`shuffle()` Shuffle a stream // e.g.
`default LazyFutureStream<U>`	`shuffle(java.util.Random random)` Shuffle a stream using specified source of randomness // e.g.
`default LazyFutureStream<U>`	`skip(long n)`
`default <T> LazyFutureStream<U>`	`skipUntil(FutureStream<T> s)` Return a Stream with the same values as this Stream, but with all values omitted until the provided stream starts emitting values.
`default LazyFutureStream<U>`	`skipUntil(java.util.function.Predicate<? super U> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to false.
`default LazyFutureStream<U>`	`skipWhile(java.util.function.Predicate<? super U> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to true.
`default LazyFutureStream<U>`	`slice(long from, long to)` Returns a limited interval from a given Stream.
`default LazyFutureStream<U>`	`sorted()`
`default LazyFutureStream<U>`	`sorted(java.util.Comparator<? super U> comparator)`
`default java.util.stream.Stream<U>`	`stream()`
`default LazyFutureStream<U>`	`sync()`
`default <T> LazyFutureStream<U>`	`takeUntil(FutureStream<T> s)` Return a Stream with the same values, but will stop emitting values once the provided Stream starts to emit values.
`default <R> LazyFutureStream<R>`	`then(java.util.function.Function<U,R> fn)` Override return type on SimpleReactStream
`default <R> LazyFutureStream<R>`	`then(java.util.function.Function<U,R> fn, java.util.concurrent.Executor service)`
`default <R> LazyFutureStream<R>`	`thenSync(java.util.function.Function<U,R> fn)`
`default LazyFutureStream<U>`	`unboundedWaitFree()` This is the default setting, internal queues are backed by a ConcurrentLinkedQueue This operator will return the next stage to using this Queue type if it has been changed
`default LazyFutureStream<U>`	`unordered()`
`LazyFutureStream<U>`	`withAsync(boolean async)`
`LazyFutureStream<U>`	`withErrorHandler(java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)`
`LazyFutureStream<U>`	`withLastActive(StreamWrapper streamWrapper)`
`default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`withLatest(FutureStream<T> s)` Similar to zip and combineLatest, except will always take the latest from this Stream while taking the last available value from the provided stream.
`LazyFutureStream<U>`	`withLazyCollector(LazyResultConsumer<U> lazy)`
`LazyFutureStream<U>`	`withParallelReduction(ParallelReductionConfig parallelReductionConfig)`
`LazyFutureStream<U>`	`withQueueFactory(QueueFactory<U> queue)`
`LazyFutureStream<U>`	`withRetrier(com.nurkiewicz.asyncretry.RetryExecutor retry)`
`LazyFutureStream<U>`	`withSubscription(Continueable sub)`
`LazyFutureStream<U>`	`withTaskExecutor(java.util.concurrent.Executor e)`
`LazyFutureStream<U>`	`withWaitStrategy(java.util.function.Consumer<java.util.concurrent.CompletableFuture> c)`
`default FutureStream<U>`	`xPer(int x, long time, java.util.concurrent.TimeUnit unit)` Allows x (specified number of) emissions with a time period before stopping emmissions until specified time has elapsed since last emission
`default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`zip(org.jooq.lambda.Seq<T> other)` Zip two streams into one.
`default <T,R> LazyFutureStream<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.
`static <T1,T2> org.jooq.lambda.Seq<org.jooq.lambda.tuple.Tuple2<T1,T2>>`	`zip(java.util.stream.Stream<T1> left, java.util.stream.Stream<T2> right)` Zip two streams into one.
`static <T1,T2,R> org.jooq.lambda.Seq<R>`	`zip(java.util.stream.Stream<T1> left, java.util.stream.Stream<T2> right, java.util.function.BiFunction<T1,T2,R> zipper)` Zip two streams into one using a `BiFunction` to produce resulting values.
`default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,R>>`	`zipFutures(FutureStream<R> other)` Zip two Streams, zipping against the underlying futures of both Streams Placeholders (Futures) will be populated immediately in the new zipped Stream and results will be populated asyncrhonously
`default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,R>>`	`zipFutures(java.util.stream.Stream<R> other)` Zip two Streams, zipping against the underlying futures of this stream
`default LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,java.lang.Long>>`	`zipFuturesWithIndex()` Zip this Stream with an index, but Zip based on the underlying tasks, not completed results.
`default LazyFutureStream<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.LazyStream
getErrorHandler, getLastActive, getLazyCollector, getParallelReduction, getWaitStrategy, run, run, run, runContinuation, runOnCurrent, runThread

Methods inherited from interface com.aol.simple.react.stream.traits.FutureStream
allMatch, anyMatch, cancel, cast, chunkLastReadIterator, close, closeOthers, closeOthers, combineLatest, combineLatest, count, findAny, firstOf, flatMapToDouble, flatMapToInt, flatMapToLong, forEachOrdered, intersperse, isParallel, iterator, lift, lift2, mapToDouble, mapToInt, mapToLong, max, merge, min, noneMatch, ofType, reversedIterator, skipUntil, slice, spliterator, takeUntil, toArray, toArray, withLatest, withLatest

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

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

Methods inherited from interface com.aol.simple.react.stream.traits.SimpleReactStream
assureSimpleReactException, bind, doOnEach, doOnEachSync, filterSync, fromListCompletableFuture, fromStreamCompletableFutureReplace, getOriginalFutures, getSubscription, handleExceptions, join, lastActiveArray, merge, peekSync, streamCompletableFutures, with

Methods inherited from interface com.aol.simple.react.stream.traits.BlockingStream
block, block, block, block, blockAndExtract, blockAndExtract, first, last

Methods inherited from interface com.aol.simple.react.stream.traits.ConfigurableStream
getRetrier, getSimpleReact, getTaskExecutor, isAsync, isEager

Methods inherited from interface com.aol.simple.react.stream.traits.ToQueue
getQueueFactory, toQueue, toQueue, toQueue

Methods inherited from interface com.aol.simple.react.stream.traits.LazyToQueue
add, getPopulator, returnPopulator, toQueue, toQueue, toQueue

- Field Detail
 - NULL
```
static final java.lang.Object NULL
```
- Method Detail
 - withTaskExecutor
```
LazyFutureStream withTaskExecutor(java.util.concurrent.Executor e)
```
 Specified by:
 
 withTaskExecutor in interface ConfigurableStream
 
 Specified by:
 
 withTaskExecutor in interface ConfigurableStream.SimpleReactConfigurableStream
 - withRetrier
```
LazyFutureStream withRetrier(com.nurkiewicz.asyncretry.RetryExecutor retry)
```
 Specified by:
 
 withRetrier in interface ConfigurableStream
 
 Specified by:
 
 withRetrier in interface ConfigurableStream.SimpleReactConfigurableStream
 - withWaitStrategy
```
LazyFutureStream withWaitStrategy(java.util.function.Consumer<java.util.concurrent.CompletableFuture> c)
```
 Specified by:
 
 withWaitStrategy in interface ConfigurableStream
 
 Specified by:
 
 withWaitStrategy in interface ConfigurableStream.SimpleReactConfigurableStream
 - withLazyCollector
```
LazyFutureStream withLazyCollector(LazyResultConsumer lazy)
```
 Specified by:
 
 withLazyCollector in interface ConfigurableStream
 
 Specified by:
 
 withLazyCollector in interface ConfigurableStream.SimpleReactConfigurableStream
 - withQueueFactory
```
LazyFutureStream withQueueFactory(QueueFactory queue)
```
 Specified by:
 
 withQueueFactory in interface ConfigurableStream
 
 Specified by:
 
 withQueueFactory in interface ConfigurableStream.SimpleReactConfigurableStream
 - withErrorHandler
```
LazyFutureStream withErrorHandler(java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)
```
 Specified by:
 
 withErrorHandler in interface ConfigurableStream
 
 Specified by:
 
 withErrorHandler in interface ConfigurableStream.SimpleReactConfigurableStream
 - withSubscription
```
LazyFutureStream withSubscription(Continueable sub)
```
 Specified by:
 
 withSubscription in interface ConfigurableStream
 
 Specified by:
 
 withSubscription in interface ConfigurableStream.SimpleReactConfigurableStream
 - withLastActive
```
LazyFutureStream withLastActive(StreamWrapper streamWrapper)
```
 Specified by:
 
 withLastActive in interface ConfigurableStream
 
 Specified by:
 
 withLastActive in interface ConfigurableStream.SimpleReactConfigurableStream
 - withAsync
```
LazyFutureStream withAsync(boolean async)
```
 Specified by:
 
 withAsync in interface ConfigurableStream
 
 Specified by:
 
 withAsync in interface ConfigurableStream.SimpleReactConfigurableStream
 - forEach
```
default void forEach(java.util.function.Consumer<? super U> c)
```
 Description copied from interface: FutureStream
 
 Stream supporting methods
 
 Specified by:
 
 forEach in interface FutureStream
 
 Specified by:
 
 forEach in interface java.lang.Iterable
 
 Specified by:
 
 forEach in interface LazyStream
 
 Specified by:
 
 forEach in interface org.jooq.lambda.Seq
 
 Specified by:
 
 forEach in interface java.util.stream.Stream
 - reduce
```
default U reduce(U identity,
 java.util.function.BinaryOperator accumulator)
```
 Specified by:
 
 reduce in interface FutureStream
 
 Specified by:
 
 reduce in interface LazyStream
 
 Specified by:
 
 reduce in interface java.util.stream.Stream
 - reduce
```
default <T> T reduce(T identity,
 java.util.function.BiFunction<T,? super U,T> accumulator,
 java.util.function.BinaryOperator<T> combiner)
```
 Specified by:
 
 reduce in interface FutureStream
 
 Specified by:
 
 reduce in interface LazyStream
 
 Specified by:
 
 reduce in interface java.util.stream.Stream
 - reduce
```
default java.util.Optional reduce(java.util.function.BinaryOperator accumulator)
```
 Specified by:
 
 reduce in interface FutureStream
 
 Specified by:
 
 reduce in interface LazyStream
 
 Specified by:
 
 reduce in interface java.util.stream.Stream
 - collect
```
default <R> R collect(java.util.function.Supplier<R> supplier,
 java.util.function.BiConsumer<R,? super U> accumulator,
 java.util.function.BiConsumer<R,R> combiner)
```
 Specified by:
 
 collect in interface FutureStream
 
 Specified by:
 
 collect in interface LazyStream
 
 Specified by:
 
 collect in interface java.util.stream.Stream
 - sync
```
default LazyFutureStream sync()
```
 Specified by:
 
 sync in interface FutureStream
 
 Specified by:
 
 sync in interface SimpleReactStream
 - async
```
default LazyFutureStream async()
```
 Specified by:
 
 async in interface FutureStream
 
 Specified by:
 
 async in interface SimpleReactStream
 - unboundedWaitFree
```
default LazyFutureStream unboundedWaitFree()
```
 This is the default setting, internal queues are backed by a ConcurrentLinkedQueue This operator will return the next stage to using this Queue type if it has been changed
 
 Returns:
 
 LazyFutureStream backed by a ConcurrentLinkedQueue
 - boundedWaitFree
```
default LazyFutureStream boundedWaitFree(int size)
```
 Use an Agrona ManyToOneConcurrentArrayQueue for the next operations (wait-free, mechanical sympathy). Note Queued data will be somewhat limited by configured concurrency level, but that flatMap operations can increase the amount of data to be buffered significantly.
 
 Parameters:
 
 size - Buffer size
 
 Returns:
 
 LazyFutureStream backed by an Agrona ManyToOneConcurrentArrayQueue
 - maxActive
```
default LazyFutureStream maxActive(int concurrentTasks)
```
 Configure the max active concurrent tasks. The last set value wins, this can't be set per stage.
```
 
 	List<String> data = new LazyReact().react(urlFile)
 										.maxActive(100)
 										.flatMap(this::loadUrls)
 										.map(this::callUrls)
 										.block();
 
 
```
 Parameters:
 
 concurrentTasks - Maximum number of active task chains
 
 Returns:
 
 LazyFutureStream with new limits set
 - thenSync
```
default <R> LazyFutureStream<R> thenSync(java.util.function.Function<U,R> fn)
```
 Specified by:
 
 thenSync in interface LazyToQueue
 
 Specified by:
 
 thenSync in interface SimpleReactStream
 - closeAll
```
default void closeAll()
```
 - findFirst
```
default java.util.Optional findFirst()
```
 Returns an Optional describing the first element of this stream, or an empty Optional if the stream is empty. If the stream has no encounter order, then any element may be returned.
 This is a short-circuiting terminal operation.
 
 Specified by:
 
 findFirst in interface FutureStream
 
 Specified by:
 
 findFirst in interface java.util.stream.Stream
 
 Returns:
 
 an Optional describing the first element of this stream, or an empty Optional if the stream is empty
 
 Throws:
 
 java.lang.NullPointerException - if the element selected is null
 - convertToEagerStream
```
default EagerFutureStream convertToEagerStream()
```
 Convert between an Lazy and Eager future stream, can be used to take advantages of each approach during a single Stream
 
 Returns:
 
 An EagerFutureStream from this LazyFutureStream, will use the same executors
 - map
```
default <R> LazyFutureStream<R> map(java.util.function.Function<? super U,? extends R> mapper)
```
 Specified by:
 
 map in interface FutureStream
 
 Specified by:
 
 map in interface org.jooq.lambda.Seq
 
 Specified by:
 
 map in interface java.util.stream.Stream
 - zipFuturesWithIndex
```
default LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,java.lang.Long>> zipFuturesWithIndex()
```
 Zip this Stream with an index, but Zip based on the underlying tasks, not completed results. e.g. two functions that return method name, but take varying lengths of time. LazyFutureStream.react(()-gt;takesALotOfTime(),()-gt;veryQuick()).zipWithIndex(); [["takesALotOfTime",0],["veryQuick",1]] Where as with standard zipWithIndex you would get a new Stream ordered by completion [["veryQuick",0],["takesALotOfTime",1]] Care should be taken not to use this method with infinite streams!
 
 Returns:
 
 Zipped Sequence
 - duplicateFuturesSeq
```
default org.jooq.lambda.tuple.Tuple2<org.jooq.lambda.Seq,org.jooq.lambda.Seq> duplicateFuturesSeq()
```
 Duplicate a Stream into two equivalent Sequences LazyFutureStream.of(1, 2, 3).duplicate() results in tuple((1,2,3),(1,2,3)) Care should be taken not to use this method with infinite streams!
 
 Returns:
 
 Two equivalent Streams
 
 See Also:
 
 duplicate()
 - duplicateFutures
```
default org.jooq.lambda.tuple.Tuple2<LazyFutureStream,LazyFutureStream> duplicateFutures()
```
 Duplicate a Stream into two equivalent LazyFutureStreams LazyFutureStream.of(1, 2, 3).duplicate() results in tuple((1,2,3),(1,2,3)) Care should be taken not to use this method with infinite streams!
 
 Returns:
 
 Two equivalent Streams
 
 See Also:
 
 duplicate()
 - zipFutures
```
default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,R>> zipFutures(java.util.stream.Stream<R> other)
```
 Zip two Streams, zipping against the underlying futures of this stream
 
 Specified by:
 
 zipFutures in interface FutureStream
 
 Parameters:
 
 other -
 
 Returns:
 - zipFutures
```
default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,R>> zipFutures(FutureStream<R> other)
```
 Zip two Streams, zipping against the underlying futures of both Streams Placeholders (Futures) will be populated immediately in the new zipped Stream and results will be populated asyncrhonously
 
 Specified by:
 
 zipFutures in interface FutureStream
 
 Parameters:
 
 other - Another FutureStream to zip Futures with
 
 Returns:
 
 New Sequence of CompletableFutures
 - chunkSinceLastRead
```
default LazyFutureStream<java.util.Collection> chunkSinceLastRead()
```
 Specified by:
 
 chunkSinceLastRead in interface FutureStream
 
 Returns:
 
 a Stream that batches all completed elements from this stream since last read attempt into a collection
 - shard
```
default <K> java.util.Map<K,LazyFutureStream> shard(java.util.Map<K,Queue> shards,
 java.util.function.Function<U,K> sharder)
```
 Break a stream into multiple Streams based of some characteristic of the elements of the Stream e.g.
```
 
 
 LazyFutureStream.of(10,20,25,30,41,43).shard(ImmutableMap.of("even",new
 Queue(),"odd",new Queue(),element-> element%2==0? "even" : "odd");
 
 
 
```
 results in 2 Streams "even": 10,20,30 "odd" : 25,41,43
 Specified by:
 
 shard in interface FutureStream
 
 Parameters:
 
 shards - Map of Queue's keyed by shard identifier
 
 sharder - Function to split split incoming elements into shards
 
 Returns:
 
 Map of new sharded Streams
 - debounce
```
default LazyFutureStream debounce(long time,
 java.util.concurrent.TimeUnit unit)
```
 Can be used to debounce (accept a single data point from a unit of time) data. This drops data. For a method that slows emissions and keeps data #see#onePer
 
 Specified by:
 
 debounce in interface FutureStream
 
 Parameters:
 
 time - Time from which to accept only one element
 
 unit - Time unit for specified time
 
 Returns:
 
 Next stage of stream, with only 1 element per specified time windows
 - skipUntil
```
default <T> LazyFutureStream skipUntil(FutureStream<T> s)
```
 Return a Stream with the same values as this Stream, but with all values omitted until the provided stream starts emitting values. Provided Stream ends the stream of values from this stream.
 
 Specified by:
 
 skipUntil in interface FutureStream
 
 Parameters:
 
 s - Stream that will start the emission of values from this stream
 
 Returns:
 
 Next stage in the Stream but with all values skipped until the provided Stream starts emitting
 - takeUntil
```
default <T> LazyFutureStream takeUntil(FutureStream<T> s)
```
 Return a Stream with the same values, but will stop emitting values once the provided Stream starts to emit values. e.g. if the provided Stream is asynchronously refreshing state from some remote store, this stream can proceed until the provided Stream succeeds in retrieving data.
 
 Specified by:
 
 takeUntil in interface FutureStream
 
 Parameters:
 
 s - Stream that will stop the emission of values from this stream
 
 Returns:
 
 Next stage in the Stream but will only emit values until provided Stream starts emitting values
 - control
```
default LazyFutureStream control(java.util.function.Function<java.util.function.Supplier,java.util.function.Supplier> fn)
```
 Allows clients to control the emission of data for the next phase of the Stream. The user specified function can delay, drop, or change elements
 
 Specified by:
 
 control in interface FutureStream
 
 Parameters:
 
 fn - Function takes a supplier, which can be used repeatedly to get the next value from the Stream. If there are no more values, a ClosedQueueException will be thrown. This function should return a Supplier which returns the desired result for the next element (or just the next element).
 
 Returns:
 
 Next stage in Stream
 - batch
```
default LazyFutureStream<java.util.Collection> batch(java.util.function.Function<java.util.function.Supplier,java.util.function.Supplier<java.util.Collection>> fn)
```
 Batch elements into a Stream of collections with user defined function
 
 Specified by:
 
 batch in interface FutureStream
 
 Parameters:
 
 fn - Function takes a supplier, which can be used repeatedly to get the next value from the Stream. If there are no more values, a ClosedQueueException will be thrown. This function should return a Supplier which creates a collection of the batched values
 
 Returns:
 
 Stream of batched values
 - batchBySize
```
default LazyFutureStream<java.util.Collection> batchBySize(int size)
```
 Batch the elements in this stream into Lists of specified size
 
 Specified by:
 
 batchBySize in interface FutureStream
 
 Parameters:
 
 size - Size of lists elements should be batched into
 
 Returns:
 
 Stream of Lists
 - batchBySize
```
default LazyFutureStream<java.util.Collection> batchBySize(int size,
 java.util.function.Supplier<java.util.Collection> supplier)
```
 Batch the elements in this stream into Collections of specified size The type of Collection is determined by the specified supplier
 
 Specified by:
 
 batchBySize in interface FutureStream
 
 Parameters:
 
 size - Size of batch
 
 supplier - Create the batch holding collection
 
 Returns:
 
 Stream of Collections
 - jitter
```
default LazyFutureStream jitter(long jitterInNanos)
```
 Introduce a random delay between events in a stream Can be used to prevent behaviour synchronizing within a system
 
 Specified by:
 
 jitter in interface FutureStream
 
 Parameters:
 
 jitterInNanos - Max number of nanos for jitter (random number less than this will be selected)/
 
 Returns:
 
 Next stage in Stream with jitter applied
 - fixedDelay
```
default LazyFutureStream fixedDelay(long time,
 java.util.concurrent.TimeUnit unit)
```
 Apply a fixed delay before emitting elements to the next phase of the Stream. Note this doesn't neccessarily imply a fixed delay between element creation (although it may do). e.g. LazyFutureStream.of(1,2,3,4).fixedDelay(1,TimeUnit.hours); Will emit 1 on start, then 2 after an hour, 3 after 2 hours and so on. However all 4 numbers will be populated in the Stream immediately. LazyFutureStream.of(1,2,3,4).withQueueFactories(QueueFactories. boundedQueue(1)).fixedDelay(1,TimeUnit.hours); Will populate each number in the Stream an hour apart.
 
 Specified by:
 
 fixedDelay in interface FutureStream
 
 Parameters:
 
 time - amount of time between emissions
 
 unit - TimeUnit for emissions
 
 Returns:
 
 Next Stage of the Stream
 - onePer
```
default LazyFutureStream onePer(long time,
 java.util.concurrent.TimeUnit unit)
```
 Slow emissions down, emiting one element per specified time period
 
 Specified by:
 
 onePer in interface FutureStream
 
 Parameters:
 
 time - Frequency period of element emission
 
 unit - Time unit for frequency period
 
 Returns:
 
 Stream with emissions slowed down by specified emission frequency
 - xPer
```
default FutureStream xPer(int x,
 long time,
 java.util.concurrent.TimeUnit unit)
```
 Allows x (specified number of) emissions with a time period before stopping emmissions until specified time has elapsed since last emission
 
 Specified by:
 
 xPer in interface FutureStream
 
 Parameters:
 
 x - Number of allowable emissions per time period
 
 time - Frequency time period
 
 unit - Frequency time unit
 
 Returns:
 
 Stream with emissions slowed down by specified emission frequency
 - batchByTime
```
default LazyFutureStream<java.util.Collection> batchByTime(long time,
 java.util.concurrent.TimeUnit unit)
```
 Organise elements in a Stream into a Collections based on the time period they pass through this stage
 
 Specified by:
 
 batchByTime in interface FutureStream
 
 Parameters:
 
 time - Time period during which all elements should be collected
 
 unit - Time unit during which all elements should be collected
 
 Returns:
 
 Stream of Lists
 - batchByTime
```
default LazyFutureStream<java.util.Collection> batchByTime(long time,
 java.util.concurrent.TimeUnit unit,
 java.util.function.Supplier<java.util.Collection> factory)
```
 Organise elements in a Stream into a Collections based on the time period they pass through this stage
 
 Specified by:
 
 batchByTime in interface FutureStream
 
 Parameters:
 
 time - Time period during which all elements should be collected
 
 unit - Time unit during which all elements should be collected
 
 factory - Instantiates the collections used in the batching
 
 Returns:
 
 Stream of collections
 - combineLatest
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> combineLatest(FutureStream<T> s)
```
 Similar to zip and withLatest, except will always take the latest from either Stream (merged with last available from the other). By contrast zip takes new / latest values from both Streams and withLatest will always take the latest from this Stream while taking the last available value from the provided stream.
 
 Specified by:
 
 combineLatest in interface FutureStream
 
 Parameters:
 
 s - Stream to merge with
 
 Returns:
 
 Stream of Tuples with the latest values from either stream
 - withLatest
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> withLatest(FutureStream<T> s)
```
 Similar to zip and combineLatest, except will always take the latest from this Stream while taking the last available value from the provided stream. By contrast zip takes new / latest values from both Streams and combineLatest takes the latest from either Stream (merged with last available from the other).
 
 Specified by:
 
 withLatest in interface FutureStream
 
 Parameters:
 
 s - Stream to merge with
 
 Returns:
 
 Stream of Tuples with the latest values from this stream
 - firstOf
```
@SafeVarargs
static  LazyFutureStream firstOf(LazyFutureStream... futureStreams)
```
 Return first Stream out of provided Streams that starts emitted results
 
 Parameters:
 
 futureStreams - Streams to race
 
 Returns:
 
 First Stream to start emitting values
 - then
```
default <R> LazyFutureStream<R> then(java.util.function.Function<U,R> fn,
 java.util.concurrent.Executor service)
```
 Specified by:
 
 then in interface LazyToQueue
 
 Specified by:
 
 then in interface SimpleReactStream
 - then
```
default <R> LazyFutureStream<R> then(java.util.function.Function<U,R> fn)
```
 Override return type on SimpleReactStream
 
 Specified by:
 
 then in interface FutureStream
 
 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 LazyFutureStream 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 LazyFutureStream 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
 - onFail
```
default LazyFutureStream onFail(java.lang.Class<? extends java.lang.Throwable> exceptionClass,
 java.util.function.Function<? extends SimpleReactFailedStageException,U> fn)
```
 Description copied from interface: SimpleReactStream
 Recover for a particular class of exceptions only. Chain onFail methods from specific Exception classes to general, as Exceptions will be caught and handled in order. e.g.
```
 
	 			onFail(IOException.class, recoveryFunction1)
	 			.onFail(Throwable.class,recovertyFunction2)
 
 
```
 For an IOException recoveryFunction1 will be executed but with the definitions reveresed
```
 
	 	onFail(Throwable.class,recovertyFunction2)
	 		.onFail(IOException.class, recoveryFunction1)
	 	
 
```
 recoveryFunction1 will not be called
 Specified by:
 
 onFail in interface FutureStream
 
 Specified by:
 
 onFail in interface SimpleReactStream
 
 Parameters:
 
 exceptionClass - Class of exceptions to recover from
 
 fn - Recovery function
 
 Returns:
 
 recovery value
 - capture
```
default LazyFutureStream 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> LazyFutureStream<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
 - anyOf
```
default <R> LazyFutureStream<R> anyOf(java.util.function.Function<U,R> fn)
```
 Description copied from interface: SimpleReactStream
 
 React to the completion of any of the events in the previous stage. Will not work reliably with Streams where filter has been applied in earlier stages. (As Filter completes the Stream for events that are filtered out, they potentially shortcircuit the completion of the stage).
 
 Specified by:
 
 anyOf in interface FutureStream
 
 Specified by:
 
 anyOf in interface SimpleReactStream
 
 Parameters:
 
 fn - Function to apply when any of the previous events complete
 
 Returns:
 
 Next stage in the stream
 - peek
```
default LazyFutureStream 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 LazyFutureStream 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> LazyFutureStream<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> LazyFutureStream<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> LazyFutureStream<R> allOf(java.util.stream.Collector collector,
 java.util.function.Function<T,R> fn)
```
 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> LazyFutureStream<R> fromStream(java.util.stream.Stream<R> stream)
```
 Specified by:
 
 fromStream in interface FutureStream
 
 Specified by:
 
 fromStream in interface SimpleReactStream
 - fromStreamOfFutures
```
default <R> LazyFutureStream<R> fromStreamOfFutures(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:
 
 fromStreamOfFutures in interface FutureStream
 
 Specified by:
 
 fromStreamOfFutures in interface SimpleReactStream
 
 Parameters:
 
 stream - JDK Stream to construct new SimpleReactStream from
 
 Returns:
 
 SimpleReactStream
 - concat
```
default LazyFutureStream concat(java.util.stream.Stream other)
```
 Concatenate two streams. // (1, 2, 3, 4, 5, 6) LazyFutureStream.of(1, 2, 3).concat(LazyFutureStream.of(4, 5, 6))
 
 Specified by:
 
 concat in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.concat(Stream[])
 - cast
```
default  LazyFutureStream cast(java.lang.Class type)
```
 Specified by:
 
 cast in interface FutureStream
 
 Specified by:
 
 cast in interface org.jooq.lambda.Seq
 - ofType
```
default  FutureStream ofType(java.lang.Class type)
```
 Keep only those elements in a stream that are of a given type. LazyFutureStream.of(1, "a", 2, "b", 3).ofType(Integer.class) gives a Stream of (1,2,3) LazyFutureStream.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)
 - intersperse
```
default LazyFutureStream 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) LazyFutureStream.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)
 - limit
```
default LazyFutureStream limit(long maxSize)
```
 Specified by:
 
 limit in interface org.jooq.lambda.Seq
 
 Specified by:
 
 limit in interface java.util.stream.Stream
 - skip
```
default LazyFutureStream skip(long n)
```
 Specified by:
 
 skip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 skip in interface java.util.stream.Stream
 - parallel
```
static  LazyFutureStream parallel(U... array)
```
 Construct an Lazy SimpleReact Stream from specified array
 
 Parameters:
 
 array - Values to react to
 
 Returns:
 
 Next SimpleReact stage
 - distinct
```
default org.jooq.lambda.Seq 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)) LazyFutureStream.of(1, 2, 3).duplicate()
 
 Specified by:
 
 duplicate in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.duplicate(Stream)
 - 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)) LazyFutureStream.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)
 - slice
```
default LazyFutureStream slice(long from,
 long to)
```
 Description copied from interface: FutureStream
 
 Returns a limited interval from a given Stream. // (4, 5) Seq.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)
 - zipWithIndex
```
default LazyFutureStream<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)) LazyFutureStream.of("a","b", "c").zipWithIndex()
 
 Specified by:
 
 zipWithIndex in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.zipWithIndex(Stream)
 - zip
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> zip(org.jooq.lambda.Seq<T> other)
```
 Zip two streams into one.
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c")) Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 See Also:
 
 zip(Stream, Stream)
 - zip
```
default <T,R> LazyFutureStream<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") LazyFutureStream.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 See Also:
 
 zip(Seq, BiFunction)
 - scanLeft
```
default <T> LazyFutureStream<T> scanLeft(T seed,
 java.util.function.BiFunction<T,? super U,T> function)
```
 Scan a stream to the left. // ("", "a", "ab", "abc") LazyFutureStream.of("a", "b", "c").scanLeft("", (u, t) > u + t)
 
 Specified by:
 
 scanLeft in interface org.jooq.lambda.Seq
 - scanRight
```
default <R> LazyFutureStream<R> scanRight(R seed,
 java.util.function.BiFunction<? super U,R,R> function)
```
 Scan a stream to the right. - careful with infinite streams! // ("", "c", "cb", "cba") LazyFutureStream.of("a", "b", "c").scanRight("", (t, u) > u + t)
 
 Specified by:
 
 scanRight in interface org.jooq.lambda.Seq
 - reverse
```
default LazyFutureStream reverse()
```
 Reverse a stream. - careful with infinite streams! // (3, 2, 1) LazyFutureStream.of(1, 2, 3).reverse()
 
 Specified by:
 
 reverse in interface FutureStream
 
 Specified by:
 
 reverse in interface org.jooq.lambda.Seq
 - shuffle
```
default LazyFutureStream shuffle()
```
 Shuffle a stream // e.g. (2, 3, 1) LazyFutureStream.of(1, 2, 3).shuffle()
 
 Specified by:
 
 shuffle in interface org.jooq.lambda.Seq
 - shuffle
```
default LazyFutureStream shuffle(java.util.Random random)
```
 Shuffle a stream using specified source of randomness // e.g. (2, 3, 1) LazyFutureStream.of(1, 2, 3).shuffle(new Random())
 
 Specified by:
 
 shuffle in interface org.jooq.lambda.Seq
 - skipWhile
```
default LazyFutureStream 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) LazyFutureStream.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 LazyFutureStream 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) LazyFutureStream.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 LazyFutureStream limitWhile(java.util.function.Predicate<? super U> predicate)
```
 Returns a stream limited to all elements for which a predicate evaluates to true. // (1, 2) LazyFutureStream.of(1, 2, 3, 4, 5).limitWhile(i -> i < 3)
 
 Specified by:
 
 limitWhile in interface org.jooq.lambda.Seq
 
 See Also:
 
 limitWhile(Stream, Predicate)
 - limitUntil
```
default LazyFutureStream limitUntil(java.util.function.Predicate<? super U> predicate)
```
 Returns a stream limited to all elements for which a predicate evaluates to false. // (1, 2) LazyFutureStream.of(1, 2, 3, 4, 5).limitUntil(i > i == 3)
 
 Specified by:
 
 limitUntil in interface org.jooq.lambda.Seq
 
 See Also:
 
 limitUntil(Stream, Predicate)
 - parallelOf
```
static  LazyFutureStream parallelOf(U... array)
```
 Construct a SimpleReact Stage from a supplied array
 
 Specified by:
 
 parallelOf in interface SimpleReactStream
 
 Parameters:
 
 array - Array of value to form the reactive stream / sequence
 
 Returns:
 
 SimpleReact Stage
 - parallelBuilder
```
static LazyReact parallelBuilder()
```
 Specified by:
 
 parallelBuilder in interface SimpleReactStream
 
 Returns:
 
 Lazy SimpleReact for handling infinite streams
 
 See Also:
 
 SimpleReact.SimpleReact()
 - parallelBuilder
```
static LazyReact parallelBuilder(int parallelism)
```
 Construct a new LazyReact 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:
 
 LazyReact instance
 - parallelCommonBuilder
```
static LazyReact parallelCommonBuilder()
```
 Specified by:
 
 parallelCommonBuilder in interface SimpleReactStream
 
 Returns:
 
 new LazyReact 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 LazyReact sequentialBuilder()
```
 Specified by:
 
 sequentialBuilder in interface SimpleReactStream
 
 Returns:
 
 new LazyReact builder configured to run on a separate thread (non-blocking current thread), sequentially New ForkJoinPool will be created
 - sequentialCommonBuilder
```
static LazyReact sequentialCommonBuilder()
```
 Specified by:
 
 sequentialCommonBuilder in interface SimpleReactStream
 
 Returns:
 
 LazyReact builder configured to run on a separate thread (non-blocking current thread), sequentially Common free thread Executor from
 - react
```
static <T> LazyFutureStream<T> react(java.util.function.Supplier<T> value)
```
 Create a parallel asynchronous stream
 
 Specified by:
 
 react in interface SimpleReactStream
 
 See Also:
 
 Stream.of(Object)
 - react
```
@SafeVarargs
static <T> LazyFutureStream<T> react(java.util.function.Supplier<T>... values)
```
 Create a parallel asynchronous stream
 
 Specified by:
 
 react in interface SimpleReactStream
 
 See Also:
 
 Stream.of(Object[])
 - of
```
static <T> LazyFutureStream<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> LazyFutureStream<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> LazyFutureStream<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()
 - iterate
```
static <T> LazyFutureStream<T> iterate(T seed,
 java.util.function.UnaryOperator<T> f)
```
 Specified by:
 
 iterate in interface org.jooq.lambda.Seq
 
 Specified by:
 
 iterate in interface java.util.stream.Stream
 
 See Also:
 
 Stream.iterate(Object, UnaryOperator)
 - generate
```
static LazyFutureStream<java.lang.Void> generate()
```
 Specified by:
 
 generate in interface org.jooq.lambda.Seq
 
 See Also:
 
 Stream.generate(Supplier)
 - generate
```
static <T> LazyFutureStream<T> generate(T value)
```
 Specified by:
 
 generate in interface org.jooq.lambda.Seq
 
 Specified by:
 
 generate in interface java.util.stream.Stream
 
 See Also:
 
 Stream.generate(Supplier)
 - generate
```
static <T> LazyFutureStream<T> generate(java.util.function.Supplier<T> s)
```
 Specified by:
 
 generate in interface org.jooq.lambda.Seq
 
 Specified by:
 
 generate in interface java.util.stream.Stream
 
 See Also:
 
 Stream.generate(Supplier)
 - of
```
static <T> LazyFutureStream<T> of(java.util.stream.Stream<T> stream)
```
 Wrap a Stream into a FutureStream.
 
 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)
 - ofIterable
```
static <T> LazyFutureStream<T> ofIterable(java.lang.Iterable<T> iterable)
```
 Wrap an Iterable into a FutureStream.
 
 Specified by:
 
 ofIterable in interface SimpleReactStream
 - of
```
static <T> LazyFutureStream<T> of(java.util.Iterator<T> iterator)
```
 Wrap an Iterator into a FutureStream.
 
 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)
 - zip
```
static <T1,T2> org.jooq.lambda.Seq<org.jooq.lambda.tuple.Tuple2<T1,T2>> zip(java.util.stream.Stream<T1> left,
 java.util.stream.Stream<T2> right)
```
 Zip two streams into one.
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c")) Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 - zip
```
static <T1,T2,R> org.jooq.lambda.Seq<R> zip(java.util.stream.Stream<T1> left,
 java.util.stream.Stream<T2> right,
 java.util.function.BiFunction<T1,T2,R> zipper)
```
 Zip two streams into one using a BiFunction to produce resulting values.
 // ("1:a", "2:b", "3:c") Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 - close
```
static void close(java.util.Iterator it)
```
 - limitWhile
```
static <T> org.jooq.lambda.Seq<T> limitWhile(java.util.stream.Stream<T> stream,
 java.util.function.Predicate<? super T> predicate)
```
 Returns a stream limited to all elements for which a predicate evaluates to true.
 // (1, 2) Seq.of(1, 2, 3, 4, 5).limitWhile(i -> i < 3)
 
 Specified by:
 
 limitWhile in interface org.jooq.lambda.Seq
 - limitUntil
```
static <T> org.jooq.lambda.Seq<T> limitUntil(java.util.stream.Stream<T> stream,
 java.util.function.Predicate<? super T> predicate)
```
 Returns a stream ed to all elements for which a predicate evaluates to true.
 // (1, 2) Seq.of(1, 2, 3, 4, 5).limitUntil(i -> i == 3)
 
 Specified by:
 
 limitUntil in interface org.jooq.lambda.Seq
 - stream
```
default java.util.stream.Stream stream()
```
 Specified by:
 
 stream in interface FutureStream
 
 Specified by:
 
 stream in interface org.jooq.lambda.Seq
 - parallel
```
default LazyFutureStream parallel()
```
 Specified by:
 
 parallel in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 parallel in interface org.jooq.lambda.Seq
 - sequential
```
default LazyFutureStream sequential()
```
 Specified by:
 
 sequential in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 sequential in interface FutureStream
 
 Specified by:
 
 sequential in interface org.jooq.lambda.Seq
 - unordered
```
default LazyFutureStream unordered()
```
 Specified by:
 
 unordered in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 unordered in interface FutureStream
 
 Specified by:
 
 unordered in interface org.jooq.lambda.Seq
 - onClose
```
default LazyFutureStream onClose(java.lang.Runnable closeHandler)
```
 Specified by:
 
 onClose in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 onClose in interface FutureStream
 
 Specified by:
 
 onClose in interface org.jooq.lambda.Seq
 - sorted
```
default LazyFutureStream sorted()
```
 Specified by:
 
 sorted in interface FutureStream
 
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq
 
 Specified by:
 
 sorted in interface java.util.stream.Stream
 - sorted
```
default LazyFutureStream sorted(java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 sorted in interface FutureStream
 
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq
 
 Specified by:
 
 sorted in interface java.util.stream.Stream
 - self
```
default LazyFutureStream self(java.util.function.Consumer<FutureStream> consumer)
```
 Give a function access to the current stage of a SimpleReact Stream
 
 Specified by:
 
 self in interface FutureStream
 
 Parameters:
 
 consumer - Consumer that will recieve current stage
 
 Returns:
 
 Self (current stage)
 - withParallelReduction
```
LazyFutureStream withParallelReduction(ParallelReductionConfig parallelReductionConfig)
```

Interface LazyFutureStream<U>

Nested Class Summary

Nested classes/interfaces inherited from interface com.aol.simple.react.stream.traits.FutureStream

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

Nested classes/interfaces inherited from interface com.aol.simple.react.stream.traits.ConfigurableStream

Field Summary

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

Method Summary

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

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.BlockingStream

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

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

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

Field Detail

NULL

Method Detail

withTaskExecutor

withRetrier

withWaitStrategy

withLazyCollector

withQueueFactory

withErrorHandler

withSubscription

withLastActive

withAsync

forEach

reduce

reduce

reduce

collect

sync

async

unboundedWaitFree

boundedWaitFree

maxActive

thenSync

closeAll

findFirst

convertToEagerStream

map

zipFuturesWithIndex

duplicateFuturesSeq

duplicateFutures

zipFutures

zipFutures

chunkSinceLastRead

shard

debounce

skipUntil

takeUntil

control

batch

batchBySize

batchBySize

jitter

fixedDelay

onePer

xPer

batchByTime

batchByTime

combineLatest

withLatest

firstOf

then

then

merge

onFail

onFail

capture

allOf

anyOf

peek

filter

flatMap

retry

allOf