LazyFutureStream (simple-react 0.99.7.1 API)

All Superinterfaces:

java.lang.AutoCloseable, BaseSimpleReactStream, java.util.stream.BaseStream<U,java.util.stream.Stream>, BlockingStream, ConfigurableStream<U,FastFuture>, FutureStreamAsyncPublisher, FutureStreamSynchronousPublisher, java.lang.Iterable, LazySimpleReactStream, LazyStream, LazyToQueue, org.reactivestreams.Publisher, com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations, org.jooq.lambda.Seq, com.aol.cyclops.sequence.SequenceM, java.util.stream.Stream, ToQueue, com.aol.cyclops.sequence.Unwrapable

All Known Implementing Classes:

LazyFutureStreamImpl
```
public interface LazyFutureStream
extends LazySimpleReactStream, LazyStream, com.aol.cyclops.sequence.SequenceM, org.jooq.lambda.Seq, LazyToQueue, ConfigurableStream<U,FastFuture>, FutureStreamAsyncPublisher, FutureStreamSynchronousPublisher
```
Lazy Stream Factory methods

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

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default OperationsOnFutures<U>`	`actOnFutures()` LazyFutureStream operators act on the results of the previous stage by default.
`default boolean`	`allMatch(java.util.function.Predicate<? super U> c)`
`default com.aol.cyclops.monad.AnyM<U>`	`anyM()`
`default boolean`	`anyMatch(java.util.function.Predicate<? super U> c)`
`default LazyFutureStream<U>`	`append(U... values)`
`default LazyFutureStream<U>`	`appendStream(java.util.stream.Stream<U> stream)`
`default LazyFutureStream<U>`	`async()`
`default <C extends java.util.Collection<U>> LazyFutureStream<C>`	`batch(java.util.function.Function<java.util.function.Supplier<U>,java.util.function.Supplier<C>> fn)` Batch elements into a Stream of collections with user defined function
`default LazyFutureStream<java.util.List<U>>`	`batchBySize(int size)` Batch the elements in this stream into Lists of specified size
`default <C extends java.util.Collection<U>> LazyFutureStream<C>`	`batchBySize(int size, java.util.function.Supplier<C> 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.List<U>>`	`batchBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit)`
`default <C extends java.util.Collection<? super U>> LazyFutureStream<C>`	`batchBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory)`
`default LazyFutureStream<java.util.List<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 <C extends java.util.Collection<U>> LazyFutureStream<C>`	`batchByTime(long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory)` Organise elements in a Stream into a Collections based on the time period they pass through this stage
`default LazyFutureStream<java.util.List<U>>`	`batchUntil(java.util.function.Predicate<? super U> predicate)`
`default <C extends java.util.Collection<? super U>> LazyFutureStream<C>`	`batchUntil(java.util.function.Predicate<? super U> predicate, java.util.function.Supplier<C> factory)`
`default LazyFutureStream<java.util.List<U>>`	`batchWhile(java.util.function.Predicate<? super U> predicate)`
`default <C extends java.util.Collection<? super U>> LazyFutureStream<C>`	`batchWhile(java.util.function.Predicate<? super U> predicate, java.util.function.Supplier<C> factory)`
`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 java.util.Iterator<java.util.Collection<U>>`	`chunkLastReadIterator()`
`default LazyFutureStream<java.util.Collection<U>>`	`chunkSinceLastRead()`
`default void`	`closeAll()` closes all open queues.
`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 <R> java.util.List<R>`	`collectIterable(java.lang.Iterable<java.util.stream.Collector> collectors)`
`default java.util.List`	`collectStream(java.util.stream.Stream<java.util.stream.Collector> collectors)`
`default LazyFutureStream<com.aol.cyclops.sequence.SequenceM<U>>`	`combinations()` `LazyFutureStream.of(1,2,3).combinations() //LazyFutureStream[SequenceM[],SequenceM[1],SequenceM[2],SequenceM[3].SequenceM[1,2],SequenceM[1,3],SequenceM[2,3] ,SequenceM[1,2,3]]`
`default LazyFutureStream<U>`	`concat(java.util.stream.Stream<U> other)` Concatenate two streams.
`default LazyFutureStream<U>`	`concat(U... other)` Concatenate two streams.
`default LazyFutureStream<U>`	`concat(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 SimpleReactStream<U>`	`convertToSimpleReact()` Convert between an Lazy and Eager SimpleReact Stream, can be used to take advantages of each approach during a single Stream Allows callers to take advantage of functionality only available in SimpleReactStreams such as allOf
`default java.util.List<LazyFutureStream<U>>`	`copy(int times)` Copy this Stream the specified number of times
`default long`	`count()`
`default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`crossJoin(java.util.stream.Stream<T> other)` Cross join 2 streams into one.
`default LazyFutureStream<U>`	`cycle()` Create a Stream that infinitely cycles this Stream
`default <R> LazyFutureStream<R>`	`cycle(java.lang.Class<R> monadC, int times)`
`default LazyFutureStream<U>`	`cycle(int times)` Create a Stream that finitely cycles this Stream, provided number of times
`default LazyFutureStream<U>`	`cycle(com.aol.cyclops.sequence.Monoid<U> m, int times)`
`default LazyFutureStream<U>`	`cycleUntil(java.util.function.Predicate<? super U> predicate)` Repeat in a Stream until specified predicate holds
`default LazyFutureStream<U>`	`cycleWhile(java.util.function.Predicate<? super U> predicate)` Repeat in a Stream while specified predicate holds
`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 LazyFutureStream<U>`	`deleteBetween(int start, int end)`
`default LazyFutureStream<U>`	`distinct()`
`default <R> com.aol.cyclops.sequence.SequenceM<U>`	`distinct(java.util.function.Function<? super U,? extends R> keyExtractor)`
`default org.jooq.lambda.tuple.Tuple2<org.jooq.lambda.Seq<U>,org.jooq.lambda.Seq<U>>`	`duplicate()` Duplicate a LazyFutureStream into two equivalent Streams.
`default org.jooq.lambda.tuple.Tuple2<LazyFutureStream<U>,LazyFutureStream<U>>`	`duplicateFutureStream()`
`default org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM<U>,com.aol.cyclops.sequence.SequenceM<U>>`	`duplicateSequence()`
`default LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,java.lang.Long>>`	`elapsed()` `LazyFutureStream.of(1,2,3,4,5) .elapsed() .forEach(System.out::println);`
`static <T> LazyFutureStream<T>`	`empty()` Create a sequential synchronous stream that runs on the current thread
`default boolean`	`endsWith(java.lang.Iterable<U> iterable)`
`default boolean`	`endsWith(java.util.stream.Stream<U> stream)`
`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>`	`findAny()`
`default java.util.Optional<U>`	`findFirst()`
`default U`	`firstValue()`
`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 <R> LazyFutureStream<R>`	`flatMapAnyM(java.util.function.Function<? super U,com.aol.cyclops.monad.AnyM<? extends R>> fn)`
`default LazyFutureStream<java.lang.String>`	`flatMapBufferedReader(java.util.function.Function<? super U,java.io.BufferedReader> fn)`
`default LazyFutureStream<java.lang.Character>`	`flatMapCharSequence(java.util.function.Function<? super U,java.lang.CharSequence> fn)`
`default <R> LazyFutureStream<R>`	`flatMapCollection(java.util.function.Function<? super U,java.util.Collection<? extends R>> fn)`
`default <R> LazyFutureStream<R>`	`flatMapCompletableFuture(java.util.function.Function<? super U,java.util.concurrent.CompletableFuture<? extends R>> flatFn)` Perform a flatMap operation where the CompletableFuture type returned is flattened from the resulting Stream If in async mode this operation is performed asyncrhonously If in sync mode this operation is performed synchronously
`default LazyFutureStream<java.lang.String>`	`flatMapFile(java.util.function.Function<? super U,java.io.File> fn)`
`default <R> LazyFutureStream<R>`	`flatMapOptional(java.util.function.Function<? super U,java.util.Optional<? extends R>> fn)`
`default <R> LazyFutureStream<R>`	`flatMapStream(java.util.function.Function<? super U,java.util.stream.BaseStream<? extends R,?>> fn)`
`default <R> LazyFutureStream<R>`	`flatMapToCompletableFutureSync(java.util.function.Function<U,java.util.concurrent.CompletableFuture<R>> flatFn)` Perform a flatMap operation where the CompletableFuture type returned is flattened from the resulting Stream This operation is performed synchronously
`default java.util.stream.DoubleStream`	`flatMapToDouble(java.util.function.Function<? super U,? extends java.util.stream.DoubleStream> mapper)`
`default java.util.stream.IntStream`	`flatMapToInt(java.util.function.Function<? super U,? extends java.util.stream.IntStream> mapper)`
`default java.util.stream.LongStream`	`flatMapToLong(java.util.function.Function<? super U,? extends java.util.stream.LongStream> mapper)`
`default LazyFutureStream<java.lang.String>`	`flatMapURL(java.util.function.Function<? super U,java.net.URL> fn)`
`default <T1> LazyFutureStream<T1>`	`flatten()`
`default U`	`foldLeft(com.aol.cyclops.sequence.Monoid<U> reducer)`
`default U`	`foldLeft(U identity, java.util.function.BinaryOperator<U> accumulator)`
`default <T> T`	`foldLeftMapToType(com.aol.cyclops.sequence.Monoid<T> reducer)`
`default U`	`foldRight(com.aol.cyclops.sequence.Monoid<U> reducer)`
`default U`	`foldRight(U identity, java.util.function.BinaryOperator<U> accumulator)`
`default <T> T`	`foldRightMapToType(com.aol.cyclops.sequence.Monoid<T> reducer)`
`default void`	`forEach(java.util.function.Consumer<? super U> c)`
`default <R1,R> LazyFutureStream<R>`	`forEach2(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super U,java.util.function.Function<? super R1,? extends R>> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied stream
`default <R1,R> LazyFutureStream<R>`	`forEach2(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super U,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction, java.util.function.Function<? super U,java.util.function.Function<? super R1,? extends R>> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied stream
`default <R1,R2,R> LazyFutureStream<R>`	`forEach3(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super U,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2, java.util.function.Function<? super U,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`default <R1,R2,R> LazyFutureStream<R>`	forEach3(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super U,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2, java.util.function.Function<? super U,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction, java.util.function.Function<? super U,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction) Perform a three level nested internal iteration over this Stream and the supplied streams
`default void`	`forEachOrdered(java.util.function.Consumer<? super U> action)`
`static <T> LazyFutureStream<T>`	`freeThread(T... values)` Create a sequential synchronous stream that runs on a free thread (commonFreeThread executor by default, shared across any instances created in this manner.
`static <T> LazyFutureStream<T>`	`freeThread(T value)` Create a sequential synchronous stream that runs on a free thread (commonFreeThread executor by default, shared across any instances created in this manner.
`default <R> LazyFutureStream<R>`	`fromStream(java.util.stream.Stream<R> stream)`
`default <R> LazyFutureStream<R>`	`fromStreamOfFutures(java.util.stream.Stream<FastFuture<R>> stream)`
`default com.aol.cyclops.sequence.future.FutureOperations<U>`	`futureOperations()`
`default com.aol.cyclops.sequence.future.FutureOperations<U>`	`futureOperations(java.util.concurrent.Executor exec)`
`static LazyFutureStream<java.lang.Void>`	`generate()` Generate an infinite Stream of null values that runs on the current thread
`static <T> LazyFutureStream<T>`	`generate(java.util.function.Supplier<T> s)` Generate an infinite Stream of value returned from Supplier that runs on the current thread
`static <T> LazyFutureStream<T>`	`generate(T value)` Generate an infinite Stream of given value that runs on the current thread
`LazyReact`	`getSimpleReact()`
`Continueable`	`getSubscription()`
`default <K> java.util.Map<K,java.util.List<U>>`	`groupBy(java.util.function.Function<? super U,? extends K> classifier)`
`default LazyFutureStream<java.util.List<U>>`	`grouped(int groupSize)`
`default com.aol.cyclops.sequence.HeadAndTail<U>`	`headAndTail()`
`default java.util.Optional<com.aol.cyclops.sequence.HeadAndTail<U>>`	`headAndTailOptional()`
`default com.aol.cyclops.sequence.HotStream<U>`	`hotStream()` Turns this LazyFutureStream into a HotStream, a connectable Stream, being executed on a thread on the in it's current task executor, that is producing data
`default com.aol.cyclops.sequence.HotStream<U>`	`hotStream(java.util.concurrent.Executor e)`
`default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`innerJoin(java.util.stream.Stream<T> other, java.util.function.BiPredicate<U,T> predicate)` Inner join 2 streams into one.
`default LazyFutureStream<U>`	`insertAt(int pos, U... values)`
`default LazyFutureStream<U>`	`insertStreamAt(int pos, java.util.stream.Stream<U> stream)`
`default LazyFutureStream<U>`	`intersperse(U value)` Returns a stream with a given value interspersed between any two values of this stream.
`default boolean`	`isParallel()`
`static <T> LazyFutureStream<T>`	`iterate(T seed, java.util.function.UnaryOperator<T> f)`
`default CloseableIterator<U>`	`iterator()`
`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 java.lang.String`	`join()`
`default java.lang.String`	`join(java.lang.String sep)`
`default java.lang.String`	`join(java.lang.String sep, java.lang.String start, java.lang.String end)`
`static <T> LazyFutureStream<T>`	`lazyFutureStream(java.util.concurrent.CompletableFuture<T>... values)` Create a 'free threaded' asynchronous stream that runs on a single thread (not current) The supplier will be executed asyncrhonously, subsequent tasks will be executed synchronously unless the async() operator is invoked.
`static <T> LazyFutureStream<T>`	`lazyFutureStream(java.util.concurrent.CompletableFuture<T> value)` Create a 'free threaded' asynchronous stream that runs on the supplied CompletableFutures executor service (unless async operator invoked , in which it will switch to the common 'free' thread executor) Subsequent tasks will be executed synchronously unless the async() operator is invoked.
`static <T> LazyFutureStream<T>`	`lazyFutureStream(java.util.Iterator<T> iterator)` Wrap an Iterator into a FutureStream that runs on the current thread
`static <T> LazyFutureStream<T>`	`lazyFutureStream(java.util.stream.Stream<T> stream)` Wrap a Stream into a FutureStream that runs on the current thread
`static <T> LazyFutureStream<T>`	`lazyFutureStreamFrom(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream)` Create a 'free threaded' asynchronous stream that runs on the supplied CompletableFutures executor service (unless async operator invoked , in which it will switch to the common 'free' thread executor) Subsequent tasks will be executed synchronously unless the async() operator is invoked.
`static <T> LazyFutureStream<T>`	`lazyFutureStreamFromIterable(java.lang.Iterable<T> iterable)` Wrap an Iterable into a FutureStream that runs on the current thread
`default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`leftOuterJoin(java.util.stream.Stream<T> other, java.util.function.BiPredicate<U,T> predicate)` Left outer join 2 streams into one.
`default LazyFutureStream<U>`	`limit(long maxSize)`
`default LazyFutureStream<U>`	`limit(long time, java.util.concurrent.TimeUnit unit)`
`default LazyFutureStream<U>`	`limitLast(int num)`
`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.
`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.
`default <R> LazyFutureStream<R>`	`map(java.util.function.Function<? super U,? extends R> mapper)`
`default <R> R`	`mapReduce(java.util.function.Function<? super U,? extends R> mapper, com.aol.cyclops.sequence.Monoid<R> reducer)`
`default <R> R`	`mapReduce(com.aol.cyclops.sequence.Monoid<R> reducer)`
`default java.util.stream.DoubleStream`	`mapToDouble(java.util.function.ToDoubleFunction<? super U> mapper)`
`default java.util.stream.IntStream`	`mapToInt(java.util.function.ToIntFunction<? super U> mapper)`
`default java.util.stream.LongStream`	`mapToLong(java.util.function.ToLongFunction<? super U> mapper)`
`default java.util.Optional<U>`	`max(java.util.Comparator<? super U> comparator)`
`LazyFutureStream<U>`	`maxActive(int concurrentTasks)` Configure the max active concurrent tasks.
`default <C extends java.lang.Comparable<C>> java.util.Optional<U>`	`maxBy(java.util.function.Function<U,C> f)`
`default <R> LazyFutureStream<R>`	`mergeLatest(LazyFutureStream<?>... streams)` Merges this stream and the supplied Streams into a single Stream where the next value is the next returned across any of the involved Streams.
`default java.util.Optional<U>`	`min(java.util.Comparator<? super U> comparator)`
`default <C extends java.lang.Comparable<C>> java.util.Optional<U>`	`minBy(java.util.function.Function<U,C> f)`
`default boolean`	`noneMatch(java.util.function.Predicate<? super U> c)`
`static <T> LazyFutureStream<T>`	`of(T... values)` Create a sequential synchronous stream that runs on the current thread
`static <T> LazyFutureStream<T>`	`of(T value)` Create a sequential synchronous stream that runs on the current thread
`default <U> LazyFutureStream<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>`	`onEmpty(U value)` Produce this stream, or an alternative stream from the `value`, in case this stream is empty.
`default LazyFutureStream<U>`	`onEmptyGet(java.util.function.Supplier<U> supplier)` Produce this stream, or an alternative stream from the `supplier`, in case this stream is empty.
`default LazyFutureStream<U>`	`onEmptySwitch(java.util.function.Supplier<java.util.stream.Stream<U>> switchTo)` If this SequenceM is empty replace it with a another Stream
`default <X extends java.lang.Throwable> LazyFutureStream<U>`	`onEmptyThrow(java.util.function.Supplier<X> supplier)` Produce this stream, or an alternative stream from the `supplier`, in case this stream is empty.
`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<SimpleReactFailedStageException,U> fn)` Recover for a particular class of exceptions only.
`default LazyFutureStream<U>`	`onFail(java.util.function.Function<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 parallel LazyFutureStream from specified array, using the configured standard parallel thread pool.
`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 in two given a predicate.
`default org.jooq.lambda.tuple.Tuple2<LazyFutureStream<U>,LazyFutureStream<U>>`	`partitionFutureStream(java.util.function.Predicate<? super U> predicate)` Partition an LazyFutureStream into two LazyFutureStreams given a predicate.
`default org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM<U>,com.aol.cyclops.sequence.SequenceM<U>>`	`partitionSequence(java.util.function.Predicate<U> splitter)`
`default <R> LazyFutureStream<R>`	`patternMatch(R defaultValue, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> case1)` Transform the elements of this Stream with a Pattern Matching case and default value
`default <R> LazyFutureStream<R>`	`patternMatch(R defaultValue, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> case1, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> case2)` Transform the elements of this Stream with a Pattern Matching case and default value
`default <R> LazyFutureStream<R>`	`patternMatch(R defaultValue, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn1, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn2, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn3)` Transform the elements of this Stream with a Pattern Matching case and default value
`default <R> LazyFutureStream<R>`	patternMatch(R defaultValue, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn1, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn2, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn3, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn4) Transform the elements of this Stream with a Pattern Matching case and default value
`default <R> LazyFutureStream<R>`	patternMatch(R defaultValue, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn1, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn2, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn3, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn4, java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn5) Transform the elements of this Stream with a Pattern Matching case and default value
`default LazyFutureStream<U>`	`peek(java.util.function.Consumer<? super U> consumer)` Peek asynchronously at the results in the current stage.
`default LazyFutureStream<U>`	`peekSync(java.util.function.Consumer<? super U> consumer)` Synchronous peek operator
`default LazyFutureStream<com.aol.cyclops.sequence.SequenceM<U>>`	`permutations()` Generate the permutations based on values in the LazyFutureStream Makes use of Streamable to store intermediate stages in a collection
`default LazyFutureStream<U>`	`prepend(U... values)`
`default LazyFutureStream<U>`	`prependStream(java.util.stream.Stream<U> stream)`
`default org.jooq.lambda.tuple.Tuple4<com.aol.cyclops.sequence.SequenceM<U>,com.aol.cyclops.sequence.SequenceM<U>,com.aol.cyclops.sequence.SequenceM<U>,com.aol.cyclops.sequence.SequenceM<U>>`	`quadruplicate()`
`static <T> LazyFutureStream<T>`	`react(java.util.function.Supplier<T>... values)` Create a 'free threaded' asynchronous stream that runs on a single thread (not current) The supplier will be executed asyncrhonously, subsequent tasks will be executed synchronously unless the async() operator is invoked.
`static <T> LazyFutureStream<T>`	`react(java.util.function.Supplier<T> value)` Create a 'free threaded' asynchronous stream that runs on a single thread (not current) The supplier will be executed asyncrhonously, subsequent tasks will be executed synchronously unless the async() operator is invoked.
`default <EX extends java.lang.Throwable> LazyFutureStream<U>`	`recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<EX,? extends U> fn)`
`default LazyFutureStream<U>`	`recover(java.util.function.Function<java.lang.Throwable,? extends U> fn)`
`default java.util.Optional<U>`	`reduce(java.util.function.BinaryOperator<U> accumulator)`
`default java.util.List<U>`	`reduce(java.lang.Iterable<com.aol.cyclops.sequence.Monoid<U>> reducers)`
`default U`	`reduce(com.aol.cyclops.sequence.Monoid<U> reducer)`
`default java.util.List<U>`	`reduce(java.util.stream.Stream<? extends com.aol.cyclops.sequence.Monoid<U>> reducers)`
`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 LazyFutureStream<U>`	`remove(U t)` Remove all occurances of the specified element from the SequenceM
`default <R> LazyFutureStream<R>`	`retry(java.util.function.Function<? super U,? extends R> fn)` Will execute this phase on the RetryExecutor (default or user supplied).
`default LazyFutureStream<U>`	`reverse()` Reverse a stream.
`default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`rightOuterJoin(java.util.stream.Stream<T> other, java.util.function.BiPredicate<U,T> predicate)` Right outer join 2 streams into one.
`default LazyFutureStream<U>`	`scanLeft(com.aol.cyclops.sequence.Monoid<U> monoid)`
`default <T> LazyFutureStream<T>`	`scanLeft(T seed, java.util.function.BiFunction<T,? super U,T> function)` Scan a stream to the left.
`default LazyFutureStream<U>`	`scanRight(com.aol.cyclops.sequence.Monoid<U> monoid)`
`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<LazyFutureStream<U>> consumer)` Give a consumer access to this Stream
`default LazyFutureStream<U>`	`sequential()`
`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 LazyFutureStream<U>`	`skip(long time, java.util.concurrent.TimeUnit unit)`
`default LazyFutureStream<U>`	`skipLast(int num)`
`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)`
`default LazyFutureStream<java.util.List<U>>`	`sliding(int size)` Create a sliding view over this Stream
`default LazyFutureStream<java.util.List<U>>`	`sliding(int size, int increment)` Create a sliding view over this Stream
`default LazyFutureStream<U>`	`sorted()`
`default LazyFutureStream<U>`	`sorted(java.util.Comparator<? super U> comparator)`
`default <R extends java.lang.Comparable<? super R>> LazyFutureStream<U>`	`sorted(java.util.function.Function<? super U,? extends R> function)`
`default org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM<U>,com.aol.cyclops.sequence.SequenceM<U>>`	`splitAt(int where)`
`default org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM<U>,com.aol.cyclops.sequence.SequenceM<U>>`	`splitBy(java.util.function.Predicate<U> splitter)`
`default java.util.Spliterator<U>`	`spliterator()`
`default org.jooq.lambda.tuple.Tuple2<java.util.Optional<U>,com.aol.cyclops.sequence.SequenceM<U>>`	`splitSequenceAtHead()`
`default boolean`	`startsWith(java.lang.Iterable<U> iterable)`
`default boolean`	`startsWith(java.util.Iterator<U> iterator)`
`default java.util.stream.Stream<U>`	`stream()`
`default void`	`subscribe(org.reactivestreams.Subscriber<? super U> s)`
`default LazyFutureStream<U>`	`subStream(int start, int end)` Return a Stream with elements before the provided start index removed, and elements after the provided end index removed
`default <R> LazyFutureStream<R>`	`switchOnNextValue(java.util.stream.Stream<LazyFutureStream> streams)` Merges this stream and the supplied Streams into a single Stream where the next value is the next returned across any of the involved Streams.
`default LazyFutureStream<U>`	`sync()`
`default <R> LazyFutureStream<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> 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 java.lang.Object[]`	`toArray()`
`default <A> A[]`	`toArray(java.util.function.IntFunction<A[]> generator)`
`default <C extends java.util.Collection<U>> C`	`toCollection(java.util.function.Supplier<C> collectionFactory)`
`default java.util.concurrent.CompletableFuture<java.util.List<U>>`	`toCompletableFuture()`
`default java.util.Collection<U>`	`toConcurrentLazyCollection()`
`default com.aol.cyclops.sequence.streamable.Streamable<U>`	`toConcurrentLazyStreamable()`
`default java.util.Collection<U>`	`toLazyCollection()`
`default java.util.List<U>`	`toList()`
`default java.util.Optional<java.util.List<U>>`	`toOptional()`
`default Queue<U>`	`toQueue()` Convert the current Stream to a simple-react Queue
`default java.util.Set<U>`	`toSet()`
`default <U> java.util.stream.Stream<U>`	`toStream()`
`default com.aol.cyclops.sequence.streamable.Streamable<U>`	`toStreamable()`
`default org.jooq.lambda.tuple.Tuple3<com.aol.cyclops.sequence.SequenceM<U>,com.aol.cyclops.sequence.SequenceM<U>,com.aol.cyclops.sequence.SequenceM<U>>`	`triplicate()`
`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()`
`default <R> R`	`unwrap()` START SEQUENCEM
`default LazyFutureStream<com.aol.cyclops.sequence.streamable.Streamable<U>>`	`windowBySizeAndTime(int maxSize, long maxTime, java.util.concurrent.TimeUnit maxTimeUnit)`
`default LazyFutureStream<com.aol.cyclops.sequence.streamable.Streamable<U>>`	`windowByTime(long time, java.util.concurrent.TimeUnit t)`
`default LazyFutureStream<com.aol.cyclops.sequence.streamable.Streamable<U>>`	`windowStatefullyWhile(java.util.function.BiPredicate<com.aol.cyclops.sequence.streamable.Streamable<? super U>,? super U> predicate)`
`default LazyFutureStream<com.aol.cyclops.sequence.streamable.Streamable<U>>`	`windowUntil(java.util.function.Predicate<? super U> predicate)`
`default LazyFutureStream<com.aol.cyclops.sequence.streamable.Streamable<U>>`	`windowWhile(java.util.function.Predicate<? super U> predicate)`
`LazyFutureStream<U>`	`withAsync(boolean async)`
`<R> LazyFutureStream<R>`	`withLastActive(LazyStreamWrapper<R> streamWrapper)`
`LazyFutureStream<U>`	`withLazyCollector(java.util.function.Supplier<LazyResultConsumer<U>> lazy)`
`LazyFutureStream<U>`	`withParallelReduction(ParallelReductionConfig parallelReductionConfig)` END SEQUENCEM
`LazyFutureStream<U>`	`withPublisherExecutor(java.util.concurrent.Executor ex)`
`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)`
`default boolean`	`xMatch(int num, java.util.function.Predicate<? super U> c)`
`default LazyFutureStream<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.
`default <S,R> LazyFutureStream<org.jooq.lambda.tuple.Tuple3<U,S,R>>`	`zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends R> third)`
`default <T2,T3,T4> LazyFutureStream<org.jooq.lambda.tuple.Tuple4<U,T2,T3,T4>>`	`zip4(java.util.stream.Stream<T2> second, java.util.stream.Stream<T3> third, java.util.stream.Stream<T4> fourth)`
`default <S,R> LazyFutureStream<R>`	`zipAnyM(com.aol.cyclops.monad.AnyM<? extends S> second, java.util.function.BiFunction<? super U,? super S,? extends R> zipper)`
`default <S,R> LazyFutureStream<R>`	`zipSequence(com.aol.cyclops.sequence.SequenceM<? extends S> second, java.util.function.BiFunction<? super U,? super S,? extends R> zipper)`
`default <S,R> LazyFutureStream<R>`	`zipStream(java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second, java.util.function.BiFunction<? super U,? super S,? extends R> zipper)`
`default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,R>>`	`zipStream(java.util.stream.Stream<R> other)`
`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.LazySimpleReactStream
assureSimpleReactException, copySimpleReactStream, doOnEach, doOnEachSync, filterSync, flatMapToCompletableFuture, getLastActive, handleExceptions, streamCompletableFutures, withErrorHandler

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

Methods inherited from interface com.aol.simple.react.stream.traits.BaseSimpleReactStream
getQueueFactory, getTaskExecutor, isAsync, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStreamFrom, simpleReactStreamFromIterable

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

Methods inherited from interface com.aol.simple.react.stream.traits.LazyStream
getErrorHandler, getLastActive, getLazyCollector, getMaxActive, getParallelReduction, run, run, runContinuation, runOnCurrent, runThread

Methods inherited from interface com.aol.cyclops.sequence.SequenceM
combinations, elementAt, fromDoubleStream, fromIntStream, fromIterable, fromIterator, fromList, fromLongStream, fromStream, get, range, rangeLong, reversedListOf, reversedOf, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, size, subscriber, timestamp, unzip, unzip3, unzip4

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

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

Methods inherited from interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations
forEachEvent, forEachWithError, forEachX, forEachXEvents, forEachXWithError

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

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

Methods inherited from interface com.aol.simple.react.reactivestreams.FutureStreamAsyncPublisher
cancel, forwardErrors, getLastActive, getPublisherExecutor, subscribeAsync, subscribeOn

Methods inherited from interface com.aol.simple.react.reactivestreams.FutureStreamSynchronousPublisher
cancel, forwardErrors, getLastActive, subscribeSync

- Method Detail
 - withPublisherExecutor
```
LazyFutureStream withPublisherExecutor(java.util.concurrent.Executor ex)
```
 Specified by:
 
 withPublisherExecutor in interface FutureStreamAsyncPublisher
 - elapsed
```
default LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,java.lang.Long>> elapsed()
```
```
 
 LazyFutureStream.of(1,2,3,4,5)
 				 		.elapsed()
 				 	.forEach(System.out::println);
 
 
```
 Specified by:
 
 elapsed in interface com.aol.cyclops.sequence.SequenceM
 
 Returns:
 
 LazyFutureStream that adds the time between elements in millis to each element
 - onEmptySwitch
```
default LazyFutureStream onEmptySwitch(java.util.function.Supplier<java.util.stream.Stream> switchTo)
```
 If this SequenceM is empty replace it with a another Stream
```
 
 assertThat(LazyFutureStream.of(4,5,6)
 							.onEmptySwitch(()->SequenceM.of(1,2,3))
 							.toList(),
 							equalTo(Arrays.asList(4,5,6)));
 
 
```
 Specified by:
 
 onEmptySwitch in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 switchTo - Supplier that will generate the alternative Stream
 
 Returns:
 
 SequenceM that will switch to an alternative Stream if empty
 - forEach3
```
default <R1,R2,R> LazyFutureStream<R> forEach3(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.Function<? super U,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2,
 java.util.function.Function<? super U,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
```
 Perform a three level nested internal iteration over this Stream and the supplied streams
```
 
 LazyFutureStream.of(1,2)
 						.forEach2(a->IntStream.range(10,13),
 						.forEach2(a->b->Stream.of(""+(a+b),"hello world"),
 									a->b->c->c+":"a+":"+b);


 //LFS[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
 
 
```
 Specified by:
 
 forEach3 in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 stream1 - Nested Stream to iterate over
 
 stream2 - Nested Stream to iterate over
 
 yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
 
 Returns:
 
 LazyFutureStream with elements generated via nested iteration
 - forEach3
```
default <R1,R2,R> LazyFutureStream<R> forEach3(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.Function<? super U,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2,
 java.util.function.Function<? super U,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction,
 java.util.function.Function<? super U,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
```
 Perform a three level nested internal iteration over this Stream and the supplied streams
```
 
 LazyFutureStream.of(1,2,3)
 .forEach3(a->IntStream.range(10,13),
 a->b->Stream.of(""+(a+b),"hello world"),
 a->b->c-> c!=3,
 a->b->c->c+":"a+":"+b);


 //LazyFutureStream[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
 
 
```
 Specified by:
 
 forEach3 in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 stream1 - Nested Stream to iterate over
 
 stream2 - Nested Stream to iterate over
 
 filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function
 
 yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
 
 Returns:
 
 LazyFutureStream with elements generated via nested iteration
 - forEach2
```
default <R1,R> LazyFutureStream<R> forEach2(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.Function<? super U,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
```
 Perform a two level nested internal iteration over this Stream and the supplied stream
```
 
 LazyFutureStream.of(1,2,3)
 						.forEach2(a->IntStream.range(10,13),
 									a->b->a+b);


 //LFS[11,14,12,15,13,16]
 
 
```
 Specified by:
 
 forEach2 in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 stream1 - Nested Stream to iterate over
 
 yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
 
 Returns:
 
 LazyFutureStream with elements generated via nested iteration
 - forEach2
```
default <R1,R> LazyFutureStream<R> forEach2(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.Function<? super U,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction,
 java.util.function.Function<? super U,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
```
 Perform a two level nested internal iteration over this Stream and the supplied stream
```
 
 LazyFutureStream.of(1,2,3)
 						.forEach2(a->IntStream.range(10,13),
 						 a->b-> a<3 && b>10,
 									a->b->a+b);


 //LFS[14,15]
 
 
```
 Specified by:
 
 forEach2 in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 stream1 - Nested Stream to iterate over
 
 filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function
 
 yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
 
 Returns:
 - patternMatch
```
default <R> LazyFutureStream<R> patternMatch(R defaultValue,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> case1)
```
 Transform the elements of this Stream with a Pattern Matching case and default value
```
 
 List<String> result = LazyFutureStream.of(1,2,3,4)
 .patternMatch(
 c->c.hasValuesWhere( (Integer i)->i%2==0 ).then(i->"even")
 )

 
 // LazyFutureStream["odd","even","odd","even"]
 
```
 Parameters:
 
 defaultValue - Value if supplied case doesn't match
 
 case1 - Function to generate a case (or chain of cases as a single case)
 
 Returns:
 
 LazyFutureStream where elements are transformed by pattern matching
 - patternMatch
```
default <R> LazyFutureStream<R> patternMatch(R defaultValue,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> case1,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> case2)
```
 Transform the elements of this Stream with a Pattern Matching case and default value
```
 

 List<String> result = LazyFutureStream.of(-2,01,2,3,4)
 .filter(i->i>0)
 .patternMatch("many",
 c->c.hasValuesWhere( (Integer i)->i==1 ).then(i->"one"),
 c->c.hasValuesWhere( (Integer i)->i==2 ).then(i->"two")
 );


 // LazyFutureStream["one","two","many","many"]
 

 
```
 Parameters:
 
 defaultValue - Value if supplied cases don't match
 
 case1 - Function to generate a case (or chain of cases as a single case)
 
 case2 - Function to generate a case (or chain of cases as a single case)
 
 Returns:
 
 LazyFutureStream where elements are transformed by pattern matching
 - patternMatch
```
default <R> LazyFutureStream<R> patternMatch(R defaultValue,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn1,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn2,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn3)
```
 Transform the elements of this Stream with a Pattern Matching case and default value
```
 

 List<String> result = LazyFutureStream.of(-2,01,2,3,4)
 .filter(i->i>0)
 .patternMatch("many",
 c->c.hasValuesWhere( (Integer i)->i==1 ).then(i->"one"),
 c->c.hasValuesWhere( (Integer i)->i==2 ).then(i->"two"),
 c->c.hasValuesWhere( (Integer i)->i==2 ).then(i->"three")
 )
 .map(opt -> opt.orElse("many"));
 
 // LazyFutureStream["one","two","three","many"]
 
```
 Parameters:
 
 defaultValue - Value if supplied cases don't match
 
 fn1 - Function to generate a case (or chain of cases as a single case)
 
 fn2 - Function to generate a case (or chain of cases as a single case)
 
 fn3 - Function to generate a case (or chain of cases as a single case)
 
 Returns:
 
 LazyFutureStream where elements are transformed by pattern matching
 - patternMatch
```
default <R> LazyFutureStream<R> patternMatch(R defaultValue,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn1,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn2,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn3,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn4)
```
 Transform the elements of this Stream with a Pattern Matching case and default value
```
 
 List<String> result = LazyFutureStream.of(-2,01,2,3,4,5)
 .filter(i->i>0)
 .patternMatch("many",
 c->c.hasValuesWhere( (Integer i)->i==1 ).then(i->"one"),
 c->c.hasValuesWhere( (Integer i)->i==2 ).then(i->"two"),
 c->c.hasValuesWhere( (Integer i)->i==2 ).then(i->"three"),
 c->c.hasValuesWhere( (Integer i)->i==2 ).then(i->"four")
 )

 
 // LazyFutureStream["one","two","three","four","many"]
 
```
 Parameters:
 
 defaultValue - Value if supplied cases don't match
 
 fn1 - Function to generate a case (or chain of cases as a single case)
 
 fn2 - Function to generate a case (or chain of cases as a single case)
 
 fn3 - Function to generate a case (or chain of cases as a single case)
 
 fn4 - Function to generate a case (or chain of cases as a single case)
 
 Returns:
 
 LazyFutureStream where elements are transformed by pattern matching
 - patternMatch
```
default <R> LazyFutureStream<R> patternMatch(R defaultValue,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn1,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn2,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn3,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn4,
 java.util.function.Function<com.aol.cyclops.matcher.builders.CheckValues<U,R>,com.aol.cyclops.matcher.builders.CheckValues<U,R>> fn5)
```
 Transform the elements of this Stream with a Pattern Matching case and default value
```
 
 List<String> result = LazyFutureStream.of(-2,01,2,3,4,5,6)
 .filter(i->i>0)
 .patternMatch("many",
 c->c.hasValuesWhere( (Integer i)->i==1 ).then(i->"one"),
 c->c.hasValuesWhere( (Integer i)->i==2 ).then(i->"two"),
 c->c.hasValuesWhere( (Integer i)->i==2 ).then(i->"three"),
 c->c.hasValuesWhere( (Integer i)->i==2 ).then(i->"four"),
 c->c.hasValuesWhere( (Integer i)->i==2 ).then(i->"five")
 )
 .map(opt -> opt.orElse("many"));
 
 // LazyFutureStream["one","two","three","four","five","many"]
 
```
 Parameters:
 
 defaultValue - Value if supplied cases don't match
 
 fn1 - Function to generate a case (or chain of cases as a single case)
 
 fn2 - Function to generate a case (or chain of cases as a single case)
 
 fn3 - Function to generate a case (or chain of cases as a single case)
 
 fn4 - Function to generate a case (or chain of cases as a single case)
 
 fn5 - Function to generate a case (or chain of cases as a single case)
 
 Returns:
 
 LazyFutureStream where elements are transformed by pattern matching
 - remove
```
default LazyFutureStream remove(U t)
```
 Remove all occurances of the specified element from the SequenceM
```
 
 	LazyFutureStream.of(1,2,3,4,5,1,2,3).remove(1)

 //LazyFutureStream[2,3,4,5,2,3]
 
 
```
 Specified by:
 
 remove in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 t - element to remove
 
 Returns:
 
 Filtered Stream
 - subStream
```
default LazyFutureStream subStream(int start,
 int end)
```
 Return a Stream with elements before the provided start index removed, and elements after the provided end index removed
```
 
 LazyFutureStream.of(1,2,3,4,5,6).subStream(1,3);


 //LazyFutureStream[2,3]
 
 
```
 Specified by:
 
 subStream in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 start - index inclusive
 
 end - index exclusive
 
 Returns:
 
 LqzyFutureStream between supplied indexes of original Sequence
 - permutations
```
default LazyFutureStream<com.aol.cyclops.sequence.SequenceM> permutations()
```
 Generate the permutations based on values in the LazyFutureStream Makes use of Streamable to store intermediate stages in a collection
 
 Specified by:
 
 permutations in interface com.aol.cyclops.sequence.SequenceM
 
 Returns:
 
 Permutations from this LazyFutureStream
 - combinations
```
default LazyFutureStream<com.aol.cyclops.sequence.SequenceM> combinations()
```
```
 
 LazyFutureStream.of(1,2,3).combinations()

 //LazyFutureStream[SequenceM[],SequenceM[1],SequenceM[2],SequenceM[3].SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]
 			,SequenceM[1,2,3]]
 
 
```
 Specified by:
 
 combinations in interface com.aol.cyclops.sequence.SequenceM
 
 Returns:
 
 All combinations of the elements in this stream
 - actOnFutures
```
default OperationsOnFutures actOnFutures()
```
 LazyFutureStream operators act on the results of the previous stage by default. That means limiting, skipping, zipping all occur once results being to stream in from active Future tasks. This operator allows access to a set of operators that behave differently. Limiting, skipping and zipping all occur on the underlying Stream of Futures. Operating on results
```
 
 new LazyReact().react(()->slow(),()->fast())
 .zipWithIndex();

 //[fast,0l],[slow,1l]
 
```
 The first result will be fast and will have index 0 (the result index) Operating on futures
```
 
 new LazyReact().react(()->slow(),()->fast())
 .actOnFutures()
 .zipWithIndex();

 //[fast,1l],[slow,0l]
 
```
 The first result will still be fast, but the index will now be the start index 1
 Returns:
 
 Access a set of operators that act on the underlying futures in this Stream.
 - iterator
```
default CloseableIterator iterator()
```
 Specified by:
 
 iterator in interface BaseSimpleReactStream
 
 Specified by:
 
 iterator in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 iterator in interface java.lang.Iterable
 
 Specified by:
 
 iterator in interface LazyStream
 - getSubscription
```
Continueable getSubscription()
```
 Specified by:
 
 getSubscription in interface BaseSimpleReactStream
 
 Specified by:
 
 getSubscription in interface LazySimpleReactStream
 - withLastActive
```
<R> LazyFutureStream<R> withLastActive(LazyStreamWrapper<R> streamWrapper)
```
 Specified by:
 
 withLastActive in interface LazySimpleReactStream
 - getSimpleReact
```
LazyReact getSimpleReact()
```
 Specified by:
 
 getSimpleReact in interface BaseSimpleReactStream
 
 Specified by:
 
 getSimpleReact in interface ConfigurableStream<U,FastFuture>
 
 Specified by:
 
 getSimpleReact in interface LazySimpleReactStream
 - subscribe
```
default void subscribe(org.reactivestreams.Subscriber<? super U> s)
```
 Specified by:
 
 subscribe in interface FutureStreamAsyncPublisher
 
 Specified by:
 
 subscribe in interface FutureStreamSynchronousPublisher
 
 Specified by:
 
 subscribe in interface org.reactivestreams.Publisher
 - chunkLastReadIterator
```
default java.util.Iterator<java.util.Collection> chunkLastReadIterator()
```
 Returns:
 
 an Iterator that chunks all completed elements from this stream since last it.next() call into a collection
 - chunkSinceLastRead
```
default LazyFutureStream<java.util.Collection> chunkSinceLastRead()
```
 Returns:
 
 a Stream that batches all completed elements from this stream since last read attempt into a collection
 - count
```
default long count()
```
 Specified by:
 
 count in interface org.jooq.lambda.Seq
 
 Specified by:
 
 count in interface java.util.stream.Stream
 - withTaskExecutor
```
LazyFutureStream withTaskExecutor(java.util.concurrent.Executor e)
```
 Specified by:
 
 withTaskExecutor in interface ConfigurableStream<U,FastFuture>
 
 Specified by:
 
 withTaskExecutor in interface LazySimpleReactStream
 - withRetrier
```
LazyFutureStream withRetrier(com.nurkiewicz.asyncretry.RetryExecutor retry)
```
 Specified by:
 
 withRetrier in interface BaseSimpleReactStream
 
 Specified by:
 
 withRetrier in interface ConfigurableStream<U,FastFuture>
 
 Specified by:
 
 withRetrier in interface LazySimpleReactStream
 - withLazyCollector
```
LazyFutureStream withLazyCollector(java.util.function.Supplier<LazyResultConsumer> lazy)
```
 - withQueueFactory
```
LazyFutureStream withQueueFactory(QueueFactory queue)
```
 Specified by:
 
 withQueueFactory in interface BaseSimpleReactStream
 
 Specified by:
 
 withQueueFactory in interface ConfigurableStream<U,FastFuture>
 
 Specified by:
 
 withQueueFactory in interface LazySimpleReactStream
 - withSubscription
```
LazyFutureStream withSubscription(Continueable sub)
```
 Specified by:
 
 withSubscription in interface BaseSimpleReactStream
 
 Specified by:
 
 withSubscription in interface ConfigurableStream<U,FastFuture>
 
 Specified by:
 
 withSubscription in interface LazySimpleReactStream
 - withAsync
```
LazyFutureStream withAsync(boolean async)
```
 Specified by:
 
 withAsync in interface ConfigurableStream<U,FastFuture>
 
 Specified by:
 
 withAsync in interface LazySimpleReactStream
 - forEach
```
default void forEach(java.util.function.Consumer<? super U> c)
```
 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
 - toQueue
```
default Queue toQueue()
```
 Description copied from interface: LazyToQueue
 
 Convert the current Stream to a simple-react Queue
 
 Specified by:
 
 toQueue in interface BaseSimpleReactStream
 
 Specified by:
 
 toQueue in interface FutureStreamAsyncPublisher
 
 Specified by:
 
 toQueue in interface FutureStreamSynchronousPublisher
 
 Specified by:
 
 toQueue in interface LazyToQueue
 
 Specified by:
 
 toQueue in interface ToQueue
 
 Returns:
 
 Data in a queue
 - reduce
```
default U reduce(U identity,
 java.util.function.BinaryOperator accumulator)
```
 Specified by:
 
 reduce in interface LazyStream
 
 Specified by:
 
 reduce in interface com.aol.cyclops.sequence.SequenceM
 
 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 LazyStream
 
 Specified by:
 
 reduce in interface com.aol.cyclops.sequence.SequenceM
 
 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 LazyStream
 
 Specified by:
 
 reduce in interface com.aol.cyclops.sequence.SequenceM
 
 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 LazyStream
 
 Specified by:
 
 collect in interface java.util.stream.Stream
 - sync
```
default LazyFutureStream sync()
```
 Specified by:
 
 sync in interface BaseSimpleReactStream
 - async
```
default LazyFutureStream async()
```
 Specified by:
 
 async in interface BaseSimpleReactStream
 - 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.
```
 
 LazyFutureStream.of(col)
 .boundedWaitFree(110)
 .flatMap(Collection::stream)
 .toList();
 
 
```
 Parameters:
 
 size - Buffer size
 
 Returns:
 
 LazyFutureStream backed by an Agrona ManyToOneConcurrentArrayQueue
 - maxActive
```
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 BaseSimpleReactStream
 
 Specified by:
 
 thenSync in interface LazySimpleReactStream
 
 Specified by:
 
 thenSync in interface LazyToQueue
 - peekSync
```
default LazyFutureStream peekSync(java.util.function.Consumer<? super U> consumer)
```
 Description copied from interface: LazySimpleReactStream
 
 Synchronous peek operator
 
 Specified by:
 
 peekSync in interface BaseSimpleReactStream
 
 Specified by:
 
 peekSync in interface LazySimpleReactStream
 
 Specified by:
 
 peekSync in interface LazyToQueue
 
 Parameters:
 
 consumer - Peek consumer
 
 Returns:
 
 Next stage
 - closeAll
```
default void closeAll()
```
 closes all open queues.
 - findFirst
```
default java.util.Optional findFirst()
```
 Specified by:
 
 findFirst in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 findFirst in interface java.util.stream.Stream
 - convertToSimpleReact
```
default SimpleReactStream convertToSimpleReact()
```
 Convert between an Lazy and Eager SimpleReact Stream, can be used to take advantages of each approach during a single Stream Allows callers to take advantage of functionality only available in SimpleReactStreams such as allOf
```
 
 LazyReact.parallelCommonBuilder()
 						.react(()->slow(),()->1,()->2)
 						.peek(System.out::println)
 						.convertToSimpleReact()
 						.allOf(list->list)
 						.block()
 
 
```
 Returns:
 
 An SimpleReactStream 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 org.jooq.lambda.Seq
 
 Specified by:
 
 map in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 map in interface java.util.stream.Stream
 - 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
 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
```
 
 LazyFutureStream.of(1,2,3,4,5,6)
 .debounce(1000,TimeUnit.SECONDS).toList();

 // [1]
 
 
```
 Specified by:
 
 debounce in interface com.aol.cyclops.sequence.SequenceM
 
 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
 - 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
 
 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 <C extends java.util.Collection> LazyFutureStream<C> batch(java.util.function.Function<java.util.function.Supplier,java.util.function.Supplier<C>> fn)
```
 Batch elements into a Stream of collections with user defined function
 
 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.List> batchBySize(int size)
```
 Batch the elements in this stream into Lists of specified size
```
 
 LazyFutureStream.of(1,2,3,4,5,6)
 					.batchBySize(3)
 					.toList();

 // [[1,2,3],[4,5,6]]
 

 
```
 Specified by:
 
 batchBySize in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 size - Size of lists elements should be batched into
 
 Returns:
 
 Stream of Lists
 - batchBySizeAndTime
```
default LazyFutureStream<java.util.List> batchBySizeAndTime(int size,
 long time,
 java.util.concurrent.TimeUnit unit)
```
 Specified by:
 
 batchBySizeAndTime in interface com.aol.cyclops.sequence.SequenceM
 - batchBySize
```
default <C extends java.util.Collection> LazyFutureStream<C> batchBySize(int size,
 java.util.function.Supplier<C> supplier)
```
 Batch the elements in this stream into Collections of specified size The type of Collection is determined by the specified supplier
```
 
 		LazyFutureStream.of(1,1,1,1,1,1)
 						.batchBySize(3,()->new TreeSet<>())
 						.toList()

 //[[1],[1]]
 

 
```
 Specified by:
 
 batchBySize in interface com.aol.cyclops.sequence.SequenceM
 
 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
```
 

 LazyFutureStream.parallelCommonBuilder()
 						.of(IntStream.range(0, 100))
 						.map(it -> it*100)
 						.jitter(10l)
 						.peek(System.out::println)
 						.block();

 

 
```
 Specified by:
 
 jitter in interface com.aol.cyclops.sequence.SequenceM
 
 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 com.aol.cyclops.sequence.SequenceM
 
 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
```
 
 		LazyFutureStream.of(1,2,3,4,5,6)
 						 .onePer(1000,TimeUnit.NANOSECONDS)
 						 .toList();

 

 
```
 Specified by:
 
 onePer in interface com.aol.cyclops.sequence.SequenceM
 
 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 LazyFutureStream 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
```
 
 LazyFutureStream.of(1,2,3,4,5,6)
 				 .xPer(6,100000000,TimeUnit.NANOSECONDS)
 				 .toList();

 

 
```
 Specified by:
 
 xPer in interface com.aol.cyclops.sequence.SequenceM
 
 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.List> 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
```
 
 	LazyFutureStream.react(()->load1(),()->load2(),()->load3(),()->load4(),()->load5(),()->load6())
 					.batchByTime(15000,TimeUnit.MICROSECONDS);

 

 
```
 Specified by:
 
 batchByTime in interface com.aol.cyclops.sequence.SequenceM
 
 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 <C extends java.util.Collection> LazyFutureStream<C> batchByTime(long time,
 java.util.concurrent.TimeUnit unit,
 java.util.function.Supplier<C> factory)
```
 Organise elements in a Stream into a Collections based on the time period they pass through this stage
```
 
 List <TreeSet<Integer>> set = LazyFutureStream.ofThread(1,1,1,1,1,1)
 .batchByTime(1500,TimeUnit.MICROSECONDS,()-> new TreeSet<>())
 .block();

 assertThat(set.get(0).size(),is(1));

 
 
```
 Specified by:
 
 batchByTime in interface com.aol.cyclops.sequence.SequenceM
 
 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
 - then
```
default <R> LazyFutureStream<R> then(java.util.function.Function<U,R> fn,
 java.util.concurrent.Executor service)
```
 Specified by:
 
 then in interface BaseSimpleReactStream
 
 Specified by:
 
 then in interface LazySimpleReactStream
 
 Specified by:
 
 then in interface LazyToQueue
 - then
```
default <R> LazyFutureStream<R> then(java.util.function.Function<U,R> fn)
```
 Description copied from interface: LazySimpleReactStream
 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 BaseSimpleReactStream
 
 Specified by:
 
 then in interface LazySimpleReactStream
 
 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
 - copy
```
default java.util.List<LazyFutureStream> copy(int times)
```
 Copy this Stream the specified number of times
```
 
 LazyFutureStream.of(1,2,3,4,5,6)
 .map(i->i+2)
 .copy(5)
 .forEach(s -> System.out.println(s.toList()));

 
```
 Parameters:
 
 times - to copy this Stream
 
 Returns:
 
 List with specified number of copies
 - switchOnNextValue
```
default <R> LazyFutureStream<R> switchOnNextValue(java.util.stream.Stream<LazyFutureStream> streams)
```
 Merges this stream and the supplied Streams into a single Stream where the next value is the next returned across any of the involved Streams. Suitable for merging infinite streams
```
 
 	LazyFutureStream<Integer> fast = ... // [1,2,3,4,5,6,7..]
 	LazyFutureStream<Integer> slow = ... // [100,200,300,400,500,600..]

 LazyFutureStream<Integer> merged = fast.switchOnNextValue(Stream.of(slow)); //[1,2,3,4,5,6,7,8,100,9,10,11,12,13,14,15,16,200..]
 
 
```
 Parameters:
 
 streams -
 
 Returns:
 - mergeLatest
```
default <R> LazyFutureStream<R> mergeLatest(LazyFutureStream<?>... streams)
```
 Merges this stream and the supplied Streams into a single Stream where the next value is the next returned across any of the involved Streams. Suitable for merging infinite streams
```
 
 	LazyFutureStream<Integer> fast = ... // [1,2,3,4,5,6,7..]
 	LazyFutureStream<Integer> slow = ... // [100,200,300,400,500,600..]

 LazyFutureStream<Integer> merged = fast.mergeLatest(slow); //[1,2,3,4,5,6,7,8,100,9,10,11,12,13,14,15,16,200..]
 
 
```
 Parameters:
 
 streams -
 
 Returns:
 - onFail
```
default LazyFutureStream onFail(java.util.function.Function<SimpleReactFailedStageException,U> fn)
```
 Description copied from interface: LazySimpleReactStream
 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 BaseSimpleReactStream
 
 Specified by:
 
 onFail in interface LazySimpleReactStream
 
 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<SimpleReactFailedStageException,U> fn)
```
 Description copied from interface: LazySimpleReactStream
 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 BaseSimpleReactStream
 
 Specified by:
 
 onFail in interface LazySimpleReactStream
 
 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: LazySimpleReactStream
 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 BaseSimpleReactStream
 
 Specified by:
 
 capture in interface LazySimpleReactStream
 
 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
 - peek
```
default LazyFutureStream peek(java.util.function.Consumer<? super U> consumer)
```
 Description copied from interface: LazySimpleReactStream
 
 Peek asynchronously at the results in the current stage. Current results are passed through to the next stage.
 
 Specified by:
 
 peek in interface BaseSimpleReactStream
 
 Specified by:
 
 peek in interface LazySimpleReactStream
 
 Specified by:
 
 peek in interface org.jooq.lambda.Seq
 
 Specified by:
 
 peek in interface com.aol.cyclops.sequence.SequenceM
 
 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: LazySimpleReactStream
 
 Removes elements that do not match the supplied predicate from the dataflow
 
 Specified by:
 
 filter in interface BaseSimpleReactStream
 
 Specified by:
 
 filter in interface LazySimpleReactStream
 
 Specified by:
 
 filter in interface org.jooq.lambda.Seq
 
 Specified by:
 
 filter in interface com.aol.cyclops.sequence.SequenceM
 
 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: LazySimpleReactStream
 
 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 BaseSimpleReactStream
 
 Specified by:
 
 flatMap in interface LazySimpleReactStream
 
 Specified by:
 
 flatMap in interface org.jooq.lambda.Seq
 
 Specified by:
 
 flatMap in interface com.aol.cyclops.sequence.SequenceM
 
 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
 - flatMapCompletableFuture
```
default <R> LazyFutureStream<R> flatMapCompletableFuture(java.util.function.Function<? super U,java.util.concurrent.CompletableFuture<? extends R>> flatFn)
```
 Perform a flatMap operation where the CompletableFuture type returned is flattened from the resulting Stream If in async mode this operation is performed asyncrhonously If in sync mode this operation is performed synchronously
```
 
 assertThat( new LazyReact()
 .of(1,2,3)
 .flatMapCompletableFuture(i->CompletableFuture.completedFuture(i))
 .block(),equalTo(Arrays.asList(1,2,3)));
 
 
```
 In this example the result of the flatMapCompletableFuture is 'flattened' to the raw integer values
 Specified by:
 
 flatMapCompletableFuture in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 flatFn - flatMap function
 
 Returns:
 
 Flatten Stream with flatFn applied
 - flatMapToCompletableFutureSync
```
default <R> LazyFutureStream<R> flatMapToCompletableFutureSync(java.util.function.Function<U,java.util.concurrent.CompletableFuture<R>> flatFn)
```
 Perform a flatMap operation where the CompletableFuture type returned is flattened from the resulting Stream This operation is performed synchronously
```
 
 assertThat( new LazyReact()
 .of(1,2,3)
 .flatMapCompletableFutureSync(i->CompletableFuture.completedFuture(i))
 .block(),equalTo(Arrays.asList(1,2,3)));
 
 
```
 In this example the result of the flatMapCompletableFuture is 'flattened' to the raw integer values
 Specified by:
 
 flatMapToCompletableFutureSync in interface BaseSimpleReactStream
 
 Specified by:
 
 flatMapToCompletableFutureSync in interface LazySimpleReactStream
 
 Parameters:
 
 flatFn - flatMap function
 
 Returns:
 
 Flatten Stream with flatFn applied
 - retry
```
default <R> LazyFutureStream<R> retry(java.util.function.Function<? super U,? extends R> fn)
```
 Description copied from interface: LazySimpleReactStream
 
 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 BaseSimpleReactStream
 
 Specified by:
 
 retry in interface LazySimpleReactStream
 
 Specified by:
 
 retry in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 fn - Function that will be executed and retried on failure
 
 Returns:
 
 Next Stage in the Strea,
 - fromStream
```
default <R> LazyFutureStream<R> fromStream(java.util.stream.Stream<R> stream)
```
 Specified by:
 
 fromStream in interface BaseSimpleReactStream
 - fromStreamOfFutures
```
default <R> LazyFutureStream<R> fromStreamOfFutures(java.util.stream.Stream<FastFuture<R>> stream)
```
 - 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
 
 Specified by:
 
 concat in interface com.aol.cyclops.sequence.SequenceM
 
 See Also:
 
 Seq.concat(Stream[])
 - concat
```
default LazyFutureStream concat(U other)
```
 Concatenate two streams.
```
 
 // (1, 2, 3, 4)
 LazyFutureStream.of(1, 2, 3).concat(4)
 
 
```
 Specified by:
 
 concat in interface org.jooq.lambda.Seq
 
 Specified by:
 
 concat in interface com.aol.cyclops.sequence.SequenceM
 
 See Also:
 
 Seq.concat(Stream[])
 - concat
```
default LazyFutureStream concat(U... other)
```
 Concatenate two streams.
```
 
 // (1, 2, 3, 4, 5, 6)
 LazyFutureStream.of(1, 2, 3).concat(4, 5, 6)
 
 
```
 Specified by:
 
 concat in interface org.jooq.lambda.Seq
 
 Specified by:
 
 concat in interface com.aol.cyclops.sequence.SequenceM
 
 See Also:
 
 Seq.concat(Stream[])
 - cast
```
default  LazyFutureStream cast(java.lang.Class type)
```
 Specified by:
 
 cast in interface BaseSimpleReactStream
 
 Specified by:
 
 cast in interface org.jooq.lambda.Seq
 
 Specified by:
 
 cast in interface com.aol.cyclops.sequence.SequenceM
 - ofType
```
default  LazyFutureStream 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 BaseSimpleReactStream
 
 Specified by:
 
 ofType in interface org.jooq.lambda.Seq
 
 Specified by:
 
 ofType in interface com.aol.cyclops.sequence.SequenceM
 - 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 BaseSimpleReactStream
 
 Specified by:
 
 intersperse in interface org.jooq.lambda.Seq
 
 Specified by:
 
 intersperse in interface com.aol.cyclops.sequence.SequenceM
 
 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 com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 limit in interface java.util.stream.Stream
 - skip
```
default LazyFutureStream skip(long n)
```
 Specified by:
 
 skip in interface BaseSimpleReactStream
 
 Specified by:
 
 skip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 skip in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 skip in interface java.util.stream.Stream
 - distinct
```
default LazyFutureStream distinct()
```
 Specified by:
 
 distinct in interface org.jooq.lambda.Seq
 
 Specified by:
 
 distinct in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 distinct in interface java.util.stream.Stream
 - sliding
```
default LazyFutureStream<java.util.List> sliding(int size)
```
 Create a sliding view over this Stream
```
 
 //futureStream of [1,2,3,4,5,6]

 List<List<Integer>> list = futureStream.sliding(2)
 .collect(Collectors.toList());


 assertThat(list.get(0),hasItems(1,2));
 assertThat(list.get(1),hasItems(2,3));
 
 
```
 Specified by:
 
 sliding in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 size - Size of sliding window
 
 Returns:
 
 Stream with sliding view over data in this stream
 - sliding
```
default LazyFutureStream<java.util.List> sliding(int size,
 int increment)
```
 Create a sliding view over this Stream
```
 
 //futureStream of [1,2,3,4,5,6,7,8]

 List<List<Integer>> list = futureStream.sliding(3,2)
 .collect(Collectors.toList());


 assertThat(list.get(0),hasItems(1,2,3));
 assertThat(list.get(1),hasItems(3,4,5));
 
 
```
 Specified by:
 
 sliding in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 size - Size of sliding window
 
 Returns:
 
 Stream with sliding view over data in this stream
 - duplicate
```
default org.jooq.lambda.tuple.Tuple2<org.jooq.lambda.Seq,org.jooq.lambda.Seq> duplicate()
```
 Duplicate a LazyFutureStream into two equivalent Streams. Two LazyFutureStreams are returned but Seq interface specifies return type is Seq. See duplicateFutureStream to see an alternative which returns LazyFutureStream
```
 

 // tuple((1, 2, 3), (1, 2, 3))

 LazyFutureStream.of(1, 2, 3).duplicate()
 
 
```
 Specified by:
 
 duplicate in interface org.jooq.lambda.Seq
 
 See Also:
 
 copy(int), Seq.duplicate(Stream)
 - duplicateFutureStream
```
default org.jooq.lambda.tuple.Tuple2<LazyFutureStream,LazyFutureStream> duplicateFutureStream()
```
 - 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 in two given a predicate. Two LazyFutureStreams are returned but Seq interface specifies return type is Seq. See partitionFutureStream to see an alternative which returns LazyFutureStream // 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:
 
 partitionFutureStream(Predicate), Seq.partition(Stream, Predicate)
 - partitionFutureStream
```
default org.jooq.lambda.tuple.Tuple2<LazyFutureStream,LazyFutureStream> partitionFutureStream(java.util.function.Predicate<? super U> predicate)
```
 Partition an LazyFutureStream into two LazyFutureStreams given a predicate.
```
 
 LazyFutureStream.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:
 
 LazyFutureStream
 
 See Also:
 
 partition(Predicate)
 - slice
```
default LazyFutureStream slice(long from,
 long to)
```
 Specified by:
 
 slice in interface org.jooq.lambda.Seq
 
 Specified by:
 
 slice in interface com.aol.cyclops.sequence.SequenceM
 - 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
 
 Specified by:
 
 zipWithIndex in interface com.aol.cyclops.sequence.SequenceM
 
 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"))
 LazyFutureStream.of(1, 2, 3)
 .zip(Seq.of("a", "b", "c"))
 
 
```
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 zip in interface com.aol.cyclops.sequence.SequenceM
 
 See Also:
 
 Seq.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
 
 Specified by:
 
 zip in interface com.aol.cyclops.sequence.SequenceM
 
 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
 
 Specified by:
 
 scanLeft in interface com.aol.cyclops.sequence.SequenceM
 - 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
 
 Specified by:
 
 scanRight in interface com.aol.cyclops.sequence.SequenceM
 - 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 org.jooq.lambda.Seq
 
 Specified by:
 
 reverse in interface com.aol.cyclops.sequence.SequenceM
 - 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
 
 Specified by:
 
 shuffle in interface com.aol.cyclops.sequence.SequenceM
 - 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
 
 Specified by:
 
 shuffle in interface com.aol.cyclops.sequence.SequenceM
 - 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
 
 Specified by:
 
 skipWhile in interface com.aol.cyclops.sequence.SequenceM
 
 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
 
 Specified by:
 
 skipUntil in interface com.aol.cyclops.sequence.SequenceM
 
 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
 
 Specified by:
 
 limitWhile in interface com.aol.cyclops.sequence.SequenceM
 
 See Also:
 
 Seq.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
 
 Specified by:
 
 limitUntil in interface com.aol.cyclops.sequence.SequenceM
 
 See Also:
 
 Seq.limitUntil(Stream, Predicate)
 - crossJoin
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> crossJoin(java.util.stream.Stream<T> other)
```
 Cross join 2 streams into one.
```
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 LazyFutureStream.of(1, 2).crossJoin(LazyFutureStream.of("a", "b"))
 
```
 Specified by:
 
 crossJoin in interface org.jooq.lambda.Seq
 
 Specified by:
 
 crossJoin in interface com.aol.cyclops.sequence.SequenceM
 - onEmpty
```
default LazyFutureStream onEmpty(U value)
```
 Produce this stream, or an alternative stream from the value, in case this stream is empty.
```
 
 LazyFutureStream.of().onEmpty(1)

 //1
 
```
 Specified by:
 
 onEmpty in interface org.jooq.lambda.Seq
 
 Specified by:
 
 onEmpty in interface com.aol.cyclops.sequence.SequenceM
 - onEmptyGet
```
default LazyFutureStream onEmptyGet(java.util.function.Supplier supplier)
```
 Produce this stream, or an alternative stream from the supplier, in case this stream is empty.
```
 
 LazyFutureStream.of().onEmptyGet(() -> 1)


 //1
 
 
```
 Specified by:
 
 onEmptyGet in interface org.jooq.lambda.Seq
 
 Specified by:
 
 onEmptyGet in interface com.aol.cyclops.sequence.SequenceM
 - onEmptyThrow
```
default <X extends java.lang.Throwable> LazyFutureStream onEmptyThrow(java.util.function.Supplier<X> supplier)
```
 Produce this stream, or an alternative stream from the supplier, in case this stream is empty.
```
 
 LazyFutureStream.of().capture(e -> ex = e).onEmptyThrow(() -> new RuntimeException()).toList();

 //throws RuntimeException
 
 
```
 Specified by:
 
 onEmptyThrow in interface org.jooq.lambda.Seq
 
 Specified by:
 
 onEmptyThrow in interface com.aol.cyclops.sequence.SequenceM
 - innerJoin
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> innerJoin(java.util.stream.Stream<T> other,
 java.util.function.BiPredicate<U,T> predicate)
```
 Inner join 2 streams into one.
```
 
 // (tuple(1, 1), tuple(2, 2))
 LazyFutureStream.of(1, 2, 3).innerJoin(Seq.of(1, 2), t -> Objects.equals(t.v1, t.v2))
 
```
 Specified by:
 
 innerJoin in interface org.jooq.lambda.Seq
 
 Specified by:
 
 innerJoin in interface com.aol.cyclops.sequence.SequenceM
 - leftOuterJoin
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> leftOuterJoin(java.util.stream.Stream<T> other,
 java.util.function.BiPredicate<U,T> predicate)
```
 Left outer join 2 streams into one.
```
 
 // (tuple(1, 1), tuple(2, 2), tuple(3, null))
 LazyFutureStream.of(1, 2, 3).leftOuterJoin(Seq.of(1, 2), t -> Objects.equals(t.v1, t.v2))
 
```
 Specified by:
 
 leftOuterJoin in interface org.jooq.lambda.Seq
 
 Specified by:
 
 leftOuterJoin in interface com.aol.cyclops.sequence.SequenceM
 - rightOuterJoin
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> rightOuterJoin(java.util.stream.Stream<T> other,
 java.util.function.BiPredicate<U,T> predicate)
```
 Right outer join 2 streams into one.
```
 
 // (tuple(1, 1), tuple(2, 2), tuple(null, 3))
 LazyFutureStream.of(1, 2).rightOuterJoin(Seq.of(1, 2, 3), t -> Objects.equals(t.v1, t.v2))
 
```
 Specified by:
 
 rightOuterJoin in interface org.jooq.lambda.Seq
 
 Specified by:
 
 rightOuterJoin in interface com.aol.cyclops.sequence.SequenceM
 - cycle
```
default LazyFutureStream cycle()
```
 Create a Stream that infinitely cycles this Stream
```
 
 assertThat(LazyFutureStream.of(1,2,2).cycle().limit(6)
 .collect(Collectors.toList()),
 equalTo(Arrays.asList(1,2,2,1,2,2));
 
 
```
 Specified by:
 
 cycle in interface org.jooq.lambda.Seq
 
 Specified by:
 
 cycle in interface com.aol.cyclops.sequence.SequenceM
 
 Returns:
 
 New cycling stream
 - cycle
```
default LazyFutureStream cycle(int times)
```
 Create a Stream that finitely cycles this Stream, provided number of times
```
 
 assertThat(LazyFutureStream.of(1,2,2).cycle(3)
 .collect(Collectors.toList()),
 equalTo(Arrays.asList(1,2,2,1,2,2,1,2,2)));
 
 
```
 Specified by:
 
 cycle in interface com.aol.cyclops.sequence.SequenceM
 
 Returns:
 
 New cycling stream
 - cycleWhile
```
default LazyFutureStream cycleWhile(java.util.function.Predicate<? super U> predicate)
```
 Repeat in a Stream while specified predicate holds
```
 
 int count =0;

 assertThat(LazyFutureStream.of(1,2,2).cycleWhile(next -> count++<6 )
 .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2)));
 
 
```
 Specified by:
 
 cycleWhile in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - cycleUntil
```
default LazyFutureStream cycleUntil(java.util.function.Predicate<? super U> predicate)
```
 Repeat in a Stream until specified predicate holds
```
 
 	count =0;
 assertThat(LazyFutureStream.of(1,2,2,3).cycleUntil(next -> count++>10 )
 .collect(Collectors.toList()),equalTo(Arrays.asList(1, 2, 2, 3, 1, 2, 2, 3, 1, 2, 2)));

 
 
```
 Specified by:
 
 cycleUntil in interface com.aol.cyclops.sequence.SequenceM
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - stream
```
default java.util.stream.Stream stream()
```
 Specified by:
 
 stream in interface org.jooq.lambda.Seq
 
 Specified by:
 
 stream in interface com.aol.cyclops.sequence.SequenceM
 - 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
 
 Specified by:
 
 parallel in interface com.aol.cyclops.sequence.SequenceM
 - sequential
```
default LazyFutureStream sequential()
```
 Specified by:
 
 sequential in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 sequential in interface org.jooq.lambda.Seq
 
 Specified by:
 
 sequential in interface com.aol.cyclops.sequence.SequenceM
 - unordered
```
default LazyFutureStream unordered()
```
 Specified by:
 
 unordered in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 unordered in interface org.jooq.lambda.Seq
 
 Specified by:
 
 unordered in interface com.aol.cyclops.sequence.SequenceM
 - 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 org.jooq.lambda.Seq
 
 Specified by:
 
 onClose in interface com.aol.cyclops.sequence.SequenceM
 - sorted
```
default LazyFutureStream sorted()
```
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq
 
 Specified by:
 
 sorted in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 sorted in interface java.util.stream.Stream
 - sorted
```
default LazyFutureStream sorted(java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq
 
 Specified by:
 
 sorted in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 sorted in interface java.util.stream.Stream
 - self
```
default LazyFutureStream self(java.util.function.Consumer<LazyFutureStream> consumer)
```
 Give a consumer access to this Stream
 
 Parameters:
 
 consumer - Consumer that will recieve current stage
 
 Returns:
 
 Self (current stage)
 - unwrap
```
default <R> R unwrap()
```
 START SEQUENCEM
 
 Specified by:
 
 unwrap in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 unwrap in interface com.aol.cyclops.sequence.Unwrapable
 - flatten
```
default <T1> LazyFutureStream<T1> flatten()
```
 Specified by:
 
 flatten in interface com.aol.cyclops.sequence.SequenceM
 - toOptional
```
default java.util.Optional<java.util.List> toOptional()
```
 Specified by:
 
 toOptional in interface com.aol.cyclops.sequence.SequenceM
 - toCompletableFuture
```
default java.util.concurrent.CompletableFuture<java.util.List> toCompletableFuture()
```
 Specified by:
 
 toCompletableFuture in interface com.aol.cyclops.sequence.SequenceM
 - spliterator
```
default java.util.Spliterator spliterator()
```
 Specified by:
 
 spliterator in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 spliterator in interface java.lang.Iterable
 
 Specified by:
 
 spliterator in interface org.jooq.lambda.Seq
 - isParallel
```
default boolean isParallel()
```
 Specified by:
 
 isParallel in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 - mapToInt
```
default java.util.stream.IntStream mapToInt(java.util.function.ToIntFunction<? super U> mapper)
```
 Specified by:
 
 mapToInt in interface org.jooq.lambda.Seq
 
 Specified by:
 
 mapToInt in interface java.util.stream.Stream
 - mapToLong
```
default java.util.stream.LongStream mapToLong(java.util.function.ToLongFunction<? super U> mapper)
```
 Specified by:
 
 mapToLong in interface org.jooq.lambda.Seq
 
 Specified by:
 
 mapToLong in interface java.util.stream.Stream
 - mapToDouble
```
default java.util.stream.DoubleStream mapToDouble(java.util.function.ToDoubleFunction<? super U> mapper)
```
 Specified by:
 
 mapToDouble in interface org.jooq.lambda.Seq
 
 Specified by:
 
 mapToDouble in interface java.util.stream.Stream
 - flatMapToInt
```
default java.util.stream.IntStream flatMapToInt(java.util.function.Function<? super U,? extends java.util.stream.IntStream> mapper)
```
 Specified by:
 
 flatMapToInt in interface org.jooq.lambda.Seq
 
 Specified by:
 
 flatMapToInt in interface java.util.stream.Stream
 - flatMapToLong
```
default java.util.stream.LongStream flatMapToLong(java.util.function.Function<? super U,? extends java.util.stream.LongStream> mapper)
```
 Specified by:
 
 flatMapToLong in interface org.jooq.lambda.Seq
 
 Specified by:
 
 flatMapToLong in interface java.util.stream.Stream
 - flatMapToDouble
```
default java.util.stream.DoubleStream flatMapToDouble(java.util.function.Function<? super U,? extends java.util.stream.DoubleStream> mapper)
```
 Specified by:
 
 flatMapToDouble in interface org.jooq.lambda.Seq
 
 Specified by:
 
 flatMapToDouble in interface java.util.stream.Stream
 - forEachOrdered
```
default void forEachOrdered(java.util.function.Consumer<? super U> action)
```
 Specified by:
 
 forEachOrdered in interface java.util.stream.Stream
 - toArray
```
default java.lang.Object[] toArray()
```
 Specified by:
 
 toArray in interface java.util.stream.Stream
 - toArray
```
default <A> A[] toArray(java.util.function.IntFunction<A[]> generator)
```
 Specified by:
 
 toArray in interface java.util.stream.Stream
 - groupBy
```
default <K> java.util.Map<K,java.util.List> groupBy(java.util.function.Function<? super U,? extends K> classifier)
```
 Specified by:
 
 groupBy in interface org.jooq.lambda.Seq
 
 Specified by:
 
 groupBy in interface com.aol.cyclops.sequence.SequenceM
 - allMatch
```
default boolean allMatch(java.util.function.Predicate<? super U> c)
```
 Specified by:
 
 allMatch in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 allMatch in interface java.util.stream.Stream
 - anyMatch
```
default boolean anyMatch(java.util.function.Predicate<? super U> c)
```
 Specified by:
 
 anyMatch in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 anyMatch in interface java.util.stream.Stream
 - noneMatch
```
default boolean noneMatch(java.util.function.Predicate<? super U> c)
```
 Specified by:
 
 noneMatch in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 noneMatch in interface java.util.stream.Stream
 - join
```
default java.lang.String join()
```
 Specified by:
 
 join in interface org.jooq.lambda.Seq
 
 Specified by:
 
 join in interface com.aol.cyclops.sequence.SequenceM
 - join
```
default java.lang.String join(java.lang.String sep)
```
 Specified by:
 
 join in interface com.aol.cyclops.sequence.SequenceM
 - join
```
default java.lang.String join(java.lang.String sep,
 java.lang.String start,
 java.lang.String end)
```
 Specified by:
 
 join in interface com.aol.cyclops.sequence.SequenceM
 - minBy
```
default <C extends java.lang.Comparable<C>> java.util.Optional minBy(java.util.function.Function<U,C> f)
```
 Specified by:
 
 minBy in interface org.jooq.lambda.Seq
 
 Specified by:
 
 minBy in interface com.aol.cyclops.sequence.SequenceM
 - min
```
default java.util.Optional min(java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 min in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 min in interface java.util.stream.Stream
 - maxBy
```
default <C extends java.lang.Comparable<C>> java.util.Optional maxBy(java.util.function.Function<U,C> f)
```
 Specified by:
 
 maxBy in interface org.jooq.lambda.Seq
 
 Specified by:
 
 maxBy in interface com.aol.cyclops.sequence.SequenceM
 - max
```
default java.util.Optional max(java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 max in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 max in interface java.util.stream.Stream
 - findAny
```
default java.util.Optional findAny()
```
 Specified by:
 
 findAny in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 findAny in interface java.util.stream.Stream
 - foldLeft
```
default U foldLeft(U identity,
 java.util.function.BinaryOperator accumulator)
```
 Specified by:
 
 foldLeft in interface com.aol.cyclops.sequence.SequenceM
 - foldRight
```
default U foldRight(U identity,
 java.util.function.BinaryOperator accumulator)
```
 Specified by:
 
 foldRight in interface com.aol.cyclops.sequence.SequenceM
 - toSet
```
default java.util.Set toSet()
```
 Specified by:
 
 toSet in interface org.jooq.lambda.Seq
 
 Specified by:
 
 toSet in interface com.aol.cyclops.sequence.SequenceM
 - toList
```
default java.util.List toList()
```
 Specified by:
 
 toList in interface org.jooq.lambda.Seq
 
 Specified by:
 
 toList in interface com.aol.cyclops.sequence.SequenceM
 - toCollection
```
default <C extends java.util.Collection> C toCollection(java.util.function.Supplier<C> collectionFactory)
```
 Specified by:
 
 toCollection in interface org.jooq.lambda.Seq
 
 Specified by:
 
 toCollection in interface com.aol.cyclops.sequence.SequenceM
 - distinct
```
default <R> com.aol.cyclops.sequence.SequenceM distinct(java.util.function.Function<? super U,? extends R> keyExtractor)
```
 Specified by:
 
 distinct in interface org.jooq.lambda.Seq
 
 Specified by:
 
 distinct in interface com.aol.cyclops.sequence.SequenceM
 - duplicateSequence
```
default org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM,com.aol.cyclops.sequence.SequenceM> duplicateSequence()
```
 Specified by:
 
 duplicateSequence in interface com.aol.cyclops.sequence.SequenceM
 - triplicate
```
default org.jooq.lambda.tuple.Tuple3<com.aol.cyclops.sequence.SequenceM,com.aol.cyclops.sequence.SequenceM,com.aol.cyclops.sequence.SequenceM> triplicate()
```
 Specified by:
 
 triplicate in interface com.aol.cyclops.sequence.SequenceM
 - quadruplicate
```
default org.jooq.lambda.tuple.Tuple4<com.aol.cyclops.sequence.SequenceM,com.aol.cyclops.sequence.SequenceM,com.aol.cyclops.sequence.SequenceM,com.aol.cyclops.sequence.SequenceM> quadruplicate()
```
 Specified by:
 
 quadruplicate in interface com.aol.cyclops.sequence.SequenceM
 - splitSequenceAtHead
```
default org.jooq.lambda.tuple.Tuple2<java.util.Optional,com.aol.cyclops.sequence.SequenceM> splitSequenceAtHead()
```
 Specified by:
 
 splitSequenceAtHead in interface com.aol.cyclops.sequence.SequenceM
 - splitAt
```
default org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM,com.aol.cyclops.sequence.SequenceM> splitAt(int where)
```
 Specified by:
 
 splitAt in interface com.aol.cyclops.sequence.SequenceM
 - splitBy
```
default org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM,com.aol.cyclops.sequence.SequenceM> splitBy(java.util.function.Predicate splitter)
```
 Specified by:
 
 splitBy in interface com.aol.cyclops.sequence.SequenceM
 - partitionSequence
```
default org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM,com.aol.cyclops.sequence.SequenceM> partitionSequence(java.util.function.Predicate splitter)
```
 Specified by:
 
 partitionSequence in interface com.aol.cyclops.sequence.SequenceM
 - cycle
```
default LazyFutureStream cycle(com.aol.cyclops.sequence.Monoid m,
 int times)
```
 Specified by:
 
 cycle in interface com.aol.cyclops.sequence.SequenceM
 - cycle
```
default <R> LazyFutureStream<R> cycle(java.lang.Class<R> monadC,
 int times)
```
 Specified by:
 
 cycle in interface com.aol.cyclops.sequence.SequenceM
 - zipStream
```
default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,R>> zipStream(java.util.stream.Stream<R> other)
```
 Specified by:
 
 zipStream in interface com.aol.cyclops.sequence.SequenceM
 - zip3
```
default <S,R> LazyFutureStream<org.jooq.lambda.tuple.Tuple3<U,S,R>> zip3(java.util.stream.Stream<? extends S> second,
 java.util.stream.Stream<? extends R> third)
```
 Specified by:
 
 zip3 in interface com.aol.cyclops.sequence.SequenceM
 - zip4
```
default <T2,T3,T4> LazyFutureStream<org.jooq.lambda.tuple.Tuple4<U,T2,T3,T4>> zip4(java.util.stream.Stream<T2> second,
 java.util.stream.Stream<T3> third,
 java.util.stream.Stream<T4> fourth)
```
 Specified by:
 
 zip4 in interface com.aol.cyclops.sequence.SequenceM
 - zipSequence
```
default <S,R> LazyFutureStream<R> zipSequence(com.aol.cyclops.sequence.SequenceM<? extends S> second,
 java.util.function.BiFunction<? super U,? super S,? extends R> zipper)
```
 Specified by:
 
 zipSequence in interface com.aol.cyclops.sequence.SequenceM
 - zipAnyM
```
default <S,R> LazyFutureStream<R> zipAnyM(com.aol.cyclops.monad.AnyM<? extends S> second,
 java.util.function.BiFunction<? super U,? super S,? extends R> zipper)
```
 Specified by:
 
 zipAnyM in interface com.aol.cyclops.sequence.SequenceM
 - zipStream
```
default <S,R> LazyFutureStream<R> zipStream(java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second,
 java.util.function.BiFunction<? super U,? super S,? extends R> zipper)
```
 Specified by:
 
 zipStream in interface com.aol.cyclops.sequence.SequenceM
 - grouped
```
default LazyFutureStream<java.util.List> grouped(int groupSize)
```
 Specified by:
 
 grouped in interface com.aol.cyclops.sequence.SequenceM
 - scanLeft
```
default LazyFutureStream scanLeft(com.aol.cyclops.sequence.Monoid monoid)
```
 Specified by:
 
 scanLeft in interface com.aol.cyclops.sequence.SequenceM
 - scanRight
```
default LazyFutureStream scanRight(com.aol.cyclops.sequence.Monoid monoid)
```
 Specified by:
 
 scanRight in interface com.aol.cyclops.sequence.SequenceM
 - xMatch
```
default boolean xMatch(int num,
 java.util.function.Predicate<? super U> c)
```
 Specified by:
 
 xMatch in interface com.aol.cyclops.sequence.SequenceM
 - headAndTail
```
default com.aol.cyclops.sequence.HeadAndTail headAndTail()
```
 Specified by:
 
 headAndTail in interface com.aol.cyclops.sequence.SequenceM
 - headAndTailOptional
```
default java.util.Optional<com.aol.cyclops.sequence.HeadAndTail> headAndTailOptional()
```
 Specified by:
 
 headAndTailOptional in interface com.aol.cyclops.sequence.SequenceM
 - mapReduce
```
default <R> R mapReduce(com.aol.cyclops.sequence.Monoid<R> reducer)
```
 Specified by:
 
 mapReduce in interface com.aol.cyclops.sequence.SequenceM
 - mapReduce
```
default <R> R mapReduce(java.util.function.Function<? super U,? extends R> mapper,
 com.aol.cyclops.sequence.Monoid<R> reducer)
```
 Specified by:
 
 mapReduce in interface com.aol.cyclops.sequence.SequenceM
 - collectStream
```
default java.util.List collectStream(java.util.stream.Stream<java.util.stream.Collector> collectors)
```
 Specified by:
 
 collectStream in interface com.aol.cyclops.sequence.SequenceM
 - collectIterable
```
default <R> java.util.List<R> collectIterable(java.lang.Iterable<java.util.stream.Collector> collectors)
```
 Specified by:
 
 collectIterable in interface com.aol.cyclops.sequence.SequenceM
 - reduce
```
default U reduce(com.aol.cyclops.sequence.Monoid reducer)
```
 Specified by:
 
 reduce in interface com.aol.cyclops.sequence.SequenceM
 - reduce
```
default java.util.List reduce(java.util.stream.Stream<? extends com.aol.cyclops.sequence.Monoid> reducers)
```
 Specified by:
 
 reduce in interface com.aol.cyclops.sequence.SequenceM
 - reduce
```
default java.util.List reduce(java.lang.Iterable<com.aol.cyclops.sequence.Monoid> reducers)
```
 Specified by:
 
 reduce in interface com.aol.cyclops.sequence.SequenceM
 - foldLeft
```
default U foldLeft(com.aol.cyclops.sequence.Monoid reducer)
```
 Specified by:
 
 foldLeft in interface com.aol.cyclops.sequence.SequenceM
 - foldLeftMapToType
```
default <T> T foldLeftMapToType(com.aol.cyclops.sequence.Monoid<T> reducer)
```
 Specified by:
 
 foldLeftMapToType in interface com.aol.cyclops.sequence.SequenceM
 - foldRight
```
default U foldRight(com.aol.cyclops.sequence.Monoid reducer)
```
 Specified by:
 
 foldRight in interface com.aol.cyclops.sequence.SequenceM
 - foldRightMapToType
```
default <T> T foldRightMapToType(com.aol.cyclops.sequence.Monoid<T> reducer)
```
 Specified by:
 
 foldRightMapToType in interface com.aol.cyclops.sequence.SequenceM
 - toStreamable
```
default com.aol.cyclops.sequence.streamable.Streamable toStreamable()
```
 Specified by:
 
 toStreamable in interface com.aol.cyclops.sequence.SequenceM
 - toStream
```
default  java.util.stream.Stream toStream()
```
 Specified by:
 
 toStream in interface com.aol.cyclops.sequence.SequenceM
 - startsWith
```
default boolean startsWith(java.lang.Iterable iterable)
```
 Specified by:
 
 startsWith in interface com.aol.cyclops.sequence.SequenceM
 - startsWith
```
default boolean startsWith(java.util.Iterator iterator)
```
 Specified by:
 
 startsWith in interface com.aol.cyclops.sequence.SequenceM
 - anyM
```
default com.aol.cyclops.monad.AnyM anyM()
```
 Specified by:
 
 anyM in interface com.aol.cyclops.sequence.SequenceM
 - flatMapAnyM
```
default <R> LazyFutureStream<R> flatMapAnyM(java.util.function.Function<? super U,com.aol.cyclops.monad.AnyM<? extends R>> fn)
```
 Specified by:
 
 flatMapAnyM in interface com.aol.cyclops.sequence.SequenceM
 - flatMapCollection
```
default <R> LazyFutureStream<R> flatMapCollection(java.util.function.Function<? super U,java.util.Collection<? extends R>> fn)
```
 Specified by:
 
 flatMapCollection in interface com.aol.cyclops.sequence.SequenceM
 - flatMapStream
```
default <R> LazyFutureStream<R> flatMapStream(java.util.function.Function<? super U,java.util.stream.BaseStream<? extends R,?>> fn)
```
 Specified by:
 
 flatMapStream in interface com.aol.cyclops.sequence.SequenceM
 - flatMapOptional
```
default <R> LazyFutureStream<R> flatMapOptional(java.util.function.Function<? super U,java.util.Optional<? extends R>> fn)
```
 Specified by:
 
 flatMapOptional in interface com.aol.cyclops.sequence.SequenceM
 - flatMapCharSequence
```
default LazyFutureStream<java.lang.Character> flatMapCharSequence(java.util.function.Function<? super U,java.lang.CharSequence> fn)
```
 Specified by:
 
 flatMapCharSequence in interface com.aol.cyclops.sequence.SequenceM
 - flatMapFile
```
default LazyFutureStream<java.lang.String> flatMapFile(java.util.function.Function<? super U,java.io.File> fn)
```
 Specified by:
 
 flatMapFile in interface com.aol.cyclops.sequence.SequenceM
 - flatMapURL
```
default LazyFutureStream<java.lang.String> flatMapURL(java.util.function.Function<? super U,java.net.URL> fn)
```
 Specified by:
 
 flatMapURL in interface com.aol.cyclops.sequence.SequenceM
 - flatMapBufferedReader
```
default LazyFutureStream<java.lang.String> flatMapBufferedReader(java.util.function.Function<? super U,java.io.BufferedReader> fn)
```
 Specified by:
 
 flatMapBufferedReader in interface com.aol.cyclops.sequence.SequenceM
 - toLazyCollection
```
default java.util.Collection toLazyCollection()
```
 Specified by:
 
 toLazyCollection in interface com.aol.cyclops.sequence.SequenceM
 - toConcurrentLazyCollection
```
default java.util.Collection toConcurrentLazyCollection()
```
 Specified by:
 
 toConcurrentLazyCollection in interface com.aol.cyclops.sequence.SequenceM
 - toConcurrentLazyStreamable
```
default com.aol.cyclops.sequence.streamable.Streamable toConcurrentLazyStreamable()
```
 Specified by:
 
 toConcurrentLazyStreamable in interface com.aol.cyclops.sequence.SequenceM
 - appendStream
```
default LazyFutureStream appendStream(java.util.stream.Stream stream)
```
 Specified by:
 
 appendStream in interface com.aol.cyclops.sequence.SequenceM
 - prependStream
```
default LazyFutureStream prependStream(java.util.stream.Stream stream)
```
 Specified by:
 
 prependStream in interface com.aol.cyclops.sequence.SequenceM
 - append
```
default LazyFutureStream append(U... values)
```
 Specified by:
 
 append in interface com.aol.cyclops.sequence.SequenceM
 - prepend
```
default LazyFutureStream prepend(U... values)
```
 Specified by:
 
 prepend in interface com.aol.cyclops.sequence.SequenceM
 - insertAt
```
default LazyFutureStream insertAt(int pos,
 U... values)
```
 Specified by:
 
 insertAt in interface com.aol.cyclops.sequence.SequenceM
 - deleteBetween
```
default LazyFutureStream deleteBetween(int start,
 int end)
```
 Specified by:
 
 deleteBetween in interface com.aol.cyclops.sequence.SequenceM
 - insertStreamAt
```
default LazyFutureStream insertStreamAt(int pos,
 java.util.stream.Stream stream)
```
 Specified by:
 
 insertStreamAt in interface com.aol.cyclops.sequence.SequenceM
 - futureOperations
```
default com.aol.cyclops.sequence.future.FutureOperations futureOperations()
```
 Returns:
 
 access to asynchronous terminal operations
 - futureOperations
```
default com.aol.cyclops.sequence.future.FutureOperations futureOperations(java.util.concurrent.Executor exec)
```
 Specified by:
 
 futureOperations in interface com.aol.cyclops.sequence.SequenceM
 - endsWith
```
default boolean endsWith(java.lang.Iterable iterable)
```
 Specified by:
 
 endsWith in interface com.aol.cyclops.sequence.SequenceM
 - endsWith
```
default boolean endsWith(java.util.stream.Stream stream)
```
 Specified by:
 
 endsWith in interface com.aol.cyclops.sequence.SequenceM
 - skip
```
default LazyFutureStream skip(long time,
 java.util.concurrent.TimeUnit unit)
```
 Specified by:
 
 skip in interface com.aol.cyclops.sequence.SequenceM
 - limit
```
default LazyFutureStream limit(long time,
 java.util.concurrent.TimeUnit unit)
```
 Specified by:
 
 limit in interface com.aol.cyclops.sequence.SequenceM
 - skipLast
```
default LazyFutureStream skipLast(int num)
```
 Specified by:
 
 skipLast in interface com.aol.cyclops.sequence.SequenceM
 - limitLast
```
default LazyFutureStream limitLast(int num)
```
 Specified by:
 
 limitLast in interface com.aol.cyclops.sequence.SequenceM
 - hotStream
```
default com.aol.cyclops.sequence.HotStream hotStream(java.util.concurrent.Executor e)
```
 Specified by:
 
 hotStream in interface com.aol.cyclops.sequence.SequenceM
 - hotStream
```
default com.aol.cyclops.sequence.HotStream hotStream()
```
 Turns this LazyFutureStream into a HotStream, a connectable Stream, being executed on a thread on the in it's current task executor, that is producing data
```
 
 HotStream<Integer> ints = new LazyReact().range(0,Integer.MAX_VALUE)
 .hotStream()


 ints.connect().forEach(System.out::println);
 //print out all the ints
 //multiple consumers are possible, so other Streams can connect on different Threads

 
 
```
 Returns:
 
 a Connectable HotStream
 - firstValue
```
default U firstValue()
```
 Specified by:
 
 firstValue in interface com.aol.cyclops.sequence.SequenceM
 - batchBySizeAndTime
```
default <C extends java.util.Collection<? super U>> LazyFutureStream<C> batchBySizeAndTime(int size,
 long time,
 java.util.concurrent.TimeUnit unit,
 java.util.function.Supplier<C> factory)
```
 Specified by:
 
 batchBySizeAndTime in interface com.aol.cyclops.sequence.SequenceM
 - windowBySizeAndTime
```
default LazyFutureStream<com.aol.cyclops.sequence.streamable.Streamable> windowBySizeAndTime(int maxSize,
 long maxTime,
 java.util.concurrent.TimeUnit maxTimeUnit)
```
 Specified by:
 
 windowBySizeAndTime in interface com.aol.cyclops.sequence.SequenceM
 - windowWhile
```
default LazyFutureStream<com.aol.cyclops.sequence.streamable.Streamable> windowWhile(java.util.function.Predicate<? super U> predicate)
```
 Specified by:
 
 windowWhile in interface com.aol.cyclops.sequence.SequenceM
 - windowUntil
```
default LazyFutureStream<com.aol.cyclops.sequence.streamable.Streamable> windowUntil(java.util.function.Predicate<? super U> predicate)
```
 Specified by:
 
 windowUntil in interface com.aol.cyclops.sequence.SequenceM
 - windowStatefullyWhile
```
default LazyFutureStream<com.aol.cyclops.sequence.streamable.Streamable> windowStatefullyWhile(java.util.function.BiPredicate<com.aol.cyclops.sequence.streamable.Streamable<? super U>,? super U> predicate)
```
 Specified by:
 
 windowStatefullyWhile in interface com.aol.cyclops.sequence.SequenceM
 - windowByTime
```
default LazyFutureStream<com.aol.cyclops.sequence.streamable.Streamable> windowByTime(long time,
 java.util.concurrent.TimeUnit t)
```
 Specified by:
 
 windowByTime in interface com.aol.cyclops.sequence.SequenceM
 - batchUntil
```
default LazyFutureStream<java.util.List> batchUntil(java.util.function.Predicate<? super U> predicate)
```
 Specified by:
 
 batchUntil in interface com.aol.cyclops.sequence.SequenceM
 - batchWhile
```
default LazyFutureStream<java.util.List> batchWhile(java.util.function.Predicate<? super U> predicate)
```
 Specified by:
 
 batchWhile in interface com.aol.cyclops.sequence.SequenceM
 - batchWhile
```
default <C extends java.util.Collection<? super U>> LazyFutureStream<C> batchWhile(java.util.function.Predicate<? super U> predicate,
 java.util.function.Supplier<C> factory)
```
 Specified by:
 
 batchWhile in interface com.aol.cyclops.sequence.SequenceM
 - sorted
```
default <R extends java.lang.Comparable<? super R>> LazyFutureStream sorted(java.util.function.Function<? super U,? extends R> function)
```
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq
 
 Specified by:
 
 sorted in interface com.aol.cyclops.sequence.SequenceM
 - batchUntil
```
default <C extends java.util.Collection<? super U>> LazyFutureStream<C> batchUntil(java.util.function.Predicate<? super U> predicate,
 java.util.function.Supplier<C> factory)
```
 Specified by:
 
 batchUntil in interface com.aol.cyclops.sequence.SequenceM
 - recover
```
default LazyFutureStream recover(java.util.function.Function<java.lang.Throwable,? extends U> fn)
```
 Specified by:
 
 recover in interface com.aol.cyclops.sequence.SequenceM
 - recover
```
default <EX extends java.lang.Throwable> LazyFutureStream recover(java.lang.Class<EX> exceptionClass,
 java.util.function.Function<EX,? extends U> fn)
```
 Specified by:
 
 recover in interface com.aol.cyclops.sequence.SequenceM
 - withParallelReduction
```
LazyFutureStream withParallelReduction(ParallelReductionConfig parallelReductionConfig)
```
 END SEQUENCEM
 - parallel
```
static  LazyFutureStream parallel(U... array)
```
 Construct an parallel LazyFutureStream from specified array, using the configured standard parallel thread pool. By default this is the Common ForkJoinPool. To use a different thread pool, the recommended approach is to construct your own LazyReact builder
 
 Specified by:
 
 parallel in interface BaseSimpleReactStream
 
 Parameters:
 
 array - Values to react to
 
 Returns:
 
 Next SimpleReact stage
 
 See Also:
 
 ThreadPools.getStandard(), ThreadPools.setUseCommon(boolean)
 - lazyFutureStreamFrom
```
static <T> LazyFutureStream<T> lazyFutureStreamFrom(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream)
```
 Create a 'free threaded' asynchronous stream that runs on the supplied CompletableFutures executor service (unless async operator invoked , in which it will switch to the common 'free' thread executor) Subsequent tasks will be executed synchronously unless the async() operator is invoked.
 - lazyFutureStream
```
static <T> LazyFutureStream<T> lazyFutureStream(java.util.concurrent.CompletableFuture<T> value)
```
 Create a 'free threaded' asynchronous stream that runs on the supplied CompletableFutures executor service (unless async operator invoked , in which it will switch to the common 'free' thread executor) Subsequent tasks will be executed synchronously unless the async() operator is invoked.
 - lazyFutureStream
```
static <T> LazyFutureStream<T> lazyFutureStream(java.util.concurrent.CompletableFuture<T>... values)
```
 Create a 'free threaded' asynchronous stream that runs on a single thread (not current) The supplier will be executed asyncrhonously, subsequent tasks will be executed synchronously unless the async() operator is invoked.
 - react
```
static <T> LazyFutureStream<T> react(java.util.function.Supplier<T> value)
```
 Create a 'free threaded' asynchronous stream that runs on a single thread (not current) The supplier will be executed asyncrhonously, subsequent tasks will be executed synchronously unless the async() operator is invoked.
 
 Specified by:
 
 react in interface BaseSimpleReactStream
 
 See Also:
 
 Stream.of(Object)
 - react
```
@SafeVarargs
static <T> LazyFutureStream<T> react(java.util.function.Supplier<T>... values)
```
 Create a 'free threaded' asynchronous stream that runs on a single thread (not current) The supplier will be executed asyncrhonously, subsequent tasks will be executed synchronously unless the async() operator is invoked.
 
 Specified by:
 
 react in interface BaseSimpleReactStream
 - of
```
static <T> LazyFutureStream<T> of(T value)
```
 Create a sequential synchronous stream that runs on the current thread
 
 Specified by:
 
 of in interface BaseSimpleReactStream
 
 Specified by:
 
 of in interface org.jooq.lambda.Seq
 
 Specified by:
 
 of in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 of in interface java.util.stream.Stream
 - of
```
@SafeVarargs
static <T> LazyFutureStream<T> of(T... values)
```
 Create a sequential synchronous stream that runs on the current thread
 
 Specified by:
 
 of in interface BaseSimpleReactStream
 
 Specified by:
 
 of in interface org.jooq.lambda.Seq
 
 Specified by:
 
 of in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 of in interface java.util.stream.Stream
 - freeThread
```
static <T> LazyFutureStream<T> freeThread(T value)
```
 Create a sequential synchronous stream that runs on a free thread (commonFreeThread executor by default, shared across any instances created in this manner.
 
 Specified by:
 
 freeThread in interface BaseSimpleReactStream
 
 See Also:
 
 ThreadPools.setUseCommon(boolean)
 - freeThread
```
@SafeVarargs
static <T> LazyFutureStream<T> freeThread(T... values)
```
 Create a sequential synchronous stream that runs on a free thread (commonFreeThread executor by default, shared across any instances created in this manner.
 
 Specified by:
 
 freeThread in interface BaseSimpleReactStream
 
 See Also:
 
 ThreadPools.setUseCommon(boolean)
 - empty
```
static <T> LazyFutureStream<T> empty()
```
 Create a sequential synchronous stream that runs on the current thread
 
 Specified by:
 
 empty in interface BaseSimpleReactStream
 
 Specified by:
 
 empty in interface org.jooq.lambda.Seq
 
 Specified by:
 
 empty in interface java.util.stream.Stream
 - 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 com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 iterate in interface java.util.stream.Stream
 
 See Also:
 
 Stream.iterate(Object, UnaryOperator)
 - generate
```
static LazyFutureStream<java.lang.Void> generate()
```
 Generate an infinite Stream of null values that runs on the current thread
 
 Specified by:
 
 generate in interface org.jooq.lambda.Seq
 
 See Also:
 
 Stream.generate(Supplier)
 - generate
```
static <T> LazyFutureStream<T> generate(T value)
```
 Generate an infinite Stream of given value that runs on the current thread
 
 Specified by:
 
 generate in interface org.jooq.lambda.Seq
 
 Specified by:
 
 generate in interface com.aol.cyclops.sequence.SequenceM
 
 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)
```
 Generate an infinite Stream of value returned from Supplier that runs on the current thread
 
 Specified by:
 
 generate in interface org.jooq.lambda.Seq
 
 Specified by:
 
 generate in interface com.aol.cyclops.sequence.SequenceM
 
 Specified by:
 
 generate in interface java.util.stream.Stream
 
 See Also:
 
 Stream.generate(Supplier)
 - lazyFutureStream
```
static <T> LazyFutureStream<T> lazyFutureStream(java.util.stream.Stream<T> stream)
```
 Wrap a Stream into a FutureStream that runs on the current thread
 - lazyFutureStreamFromIterable
```
static <T> LazyFutureStream<T> lazyFutureStreamFromIterable(java.lang.Iterable<T> iterable)
```
 Wrap an Iterable into a FutureStream that runs on the current thread
 - lazyFutureStream
```
static <T> LazyFutureStream<T> lazyFutureStream(java.util.Iterator<T> iterator)
```
 Wrap an Iterator into a FutureStream that runs on the current thread

Interface LazyFutureStream<U>

Nested Class Summary

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

Method Summary

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

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

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

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

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

Methods inherited from interface com.aol.cyclops.sequence.SequenceM

Methods inherited from interface org.jooq.lambda.Seq

Methods inherited from interface java.util.stream.Stream

Methods inherited from interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations

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

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

Methods inherited from interface com.aol.simple.react.reactivestreams.FutureStreamAsyncPublisher

Methods inherited from interface com.aol.simple.react.reactivestreams.FutureStreamSynchronousPublisher

Method Detail

withPublisherExecutor

elapsed

onEmptySwitch

forEach3

forEach3

forEach2

forEach2

patternMatch

patternMatch

patternMatch

patternMatch

patternMatch

remove

subStream

permutations

combinations

actOnFutures

iterator

getSubscription

withLastActive

getSimpleReact

subscribe

chunkLastReadIterator

chunkSinceLastRead

count

withTaskExecutor

withRetrier

withLazyCollector

withQueueFactory

withSubscription

withAsync

forEach

toQueue

reduce

reduce

reduce

collect

sync

async

unboundedWaitFree

boundedWaitFree

maxActive

thenSync

peekSync

closeAll

findFirst

convertToSimpleReact

map

shard

debounce

control

batch

batchBySize

batchBySizeAndTime

batchBySize

jitter

fixedDelay

onePer

xPer

batchByTime

batchByTime

then