LazyFutureStream (simple-react 1.0.0-RC4 API)

All Superinterfaces:

java.lang.AutoCloseable, BaseSimpleReactStream, java.util.stream.BaseStream<U,java.util.stream.Stream>, BlockingStream, org.jooq.lambda.Collectable, ConfigurableStream<U,FastFuture>, ConvertableSequence, CyclopsCollectable, ExtendedTraversable, Filterable, FilterableFunctor, Foldable, Functor, FutureStreamSynchronousPublisher, java.lang.Iterable, IterableFilterable, IterableFoldable, IterableFunctor, JoolManipulation, JoolWindowing, LazySimpleReactStream, LazyStream, LazyToQueue, org.reactivestreams.Publisher, ReactiveSeq, ReactiveStreamsTerminalOperations, org.jooq.lambda.Seq, java.util.stream.Stream, ToQueue, TransformerTraversable, Traversable, Unit, Unwrapable, ZippingApplicativable

All Known Implementing Classes:

LazyFutureStreamImpl
```
public interface LazyFutureStream
extends Functor, Filterable, LazySimpleReactStream, LazyStream, ReactiveSeq, LazyToQueue, ConfigurableStream<U,FastFuture>, 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 AnyMSeq<U>`	`anyM()`
`default <R> ZippingApplicativable<R>`	`ap1(java.util.function.Function<? super U,? extends R> fn)`
`default LazyFutureStream<U>`	`append(U... values)` Append values to the end of this ReactiveSeq
`default LazyFutureStream<U>`	`appendStream(java.util.stream.Stream<U> stream)` Append Stream to this ReactiveSeq
`default <R> ApplyingZippingApplicativeBuilder<U,R,ZippingApplicativable<R>>`	`applicatives()`
`default LazyFutureStream<U>`	`async()`
`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<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<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`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 LazyFutureStream<ReactiveSeq<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>`	`combine(java.util.function.BiPredicate<? super U,? super U> predicate, java.util.function.BinaryOperator<U> op)` Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping & reduction operation.
`default LazyFutureStream<U>`	`concat(java.util.stream.Stream<? extends 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<? extends T> other)` Cross join 2 streams into one.
`default LazyFutureStream<U>`	`cycle()` Create a Stream that infinitely cycles this Stream
`default LazyFutureStream<U>`	`cycle(int times)` Create a Stream that finitely cycles this Stream, provided number of times
`default LazyFutureStream<U>`	`cycle(Monoid<U> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified 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)` Delete elements between given indexes in a Stream
`default LazyFutureStream<U>`	`distinct()`
`default <R> ReactiveSeq<U>`	`distinct(java.util.function.Function<? super U,? extends R> keyExtractor)`
`default LazyFutureStream<U>`	`dropRight(int num)`
`default LazyFutureStream<U>`	`dropUntil(java.util.function.Predicate<? super U> p)`
`default LazyFutureStream<U>`	`dropWhile(java.util.function.Predicate<? super U> p)`
`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<ReactiveSeq<U>,ReactiveSeq<U>>`	`duplicateSequence()` Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`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.util.stream.Stream<U> stream)` `assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Stream.of(5,6)));`
`default boolean`	`endsWithIterable(java.lang.Iterable<U> iterable)` `assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Arrays.asList(5,6)));`
`default LazyFutureStream<U>`	`filter(java.util.function.Predicate<? super U> p)` Keep only elements for which the supplied predicates hold e.g.
`default LazyFutureStream<U>`	`filterNot(java.util.function.Predicate<? super U> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`default java.util.Optional<U>`	`findAny()`
`default java.util.Optional<U>`	`findFirst()`
`default U`	`firstValue()` `assertThat(ReactiveSeq.of(1,2,3,4) .map(u->{throw new RuntimeException();}) .recover(e->"hello") .firstValue(),equalTo("hello"));`
`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,AnyM<? extends R>> flatFn)` Allows flatMap return type to be any Monad type
`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 <R> LazyFutureStream<R>`	`flatMapIterable(java.util.function.Function<? super U,? extends java.lang.Iterable<? extends R>> fn)` FlatMap where the result is a Collection, flattens the resultant collections into the host ReactiveSeq
`default <R> LazyFutureStream<R>`	`flatMapStream(java.util.function.Function<? super U,java.util.stream.BaseStream<? extends R,?>> fn)` flatMap operation
`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 <T1> LazyFutureStream<T1>`	`flatten()` join / flatten one level of a nested hierarchy
`default IterableFoldable<U>`	`foldable()`
`default <R> R`	`foldRight(R identity, java.util.function.BiFunction<? super U,? super R,? extends R> accumulator)`
`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 <X extends java.lang.Throwable> void`	`forEachEvent(java.util.function.Consumer<? super U> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)` Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers when the entire Stream has been processed an onComplete event will be recieved.
`default void`	`forEachOrdered(java.util.function.Consumer<? super U> action)`
`default <X extends java.lang.Throwable> void`	`forEachWithError(java.util.function.Consumer<? super U> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError)` Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,
`default <X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachX(long numberOfElements, java.util.function.Consumer<? super U> consumer)` Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time.
`default <X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachXEvents(long numberOfElements, java.util.function.Consumer<? super U> consumer, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)` Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
`default <X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachXWithError(long numberOfElements, java.util.function.Consumer<? super U> consumer, java.util.function.Consumer<? super java.lang.Throwable> consumerError)` Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
`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 FutureOperations<U>`	`futureOperations()`
`default FutureOperations<U>`	`futureOperations(java.util.concurrent.Executor exec)` Access asynchronous terminal operations (each returns a Future)
`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 <C extends java.util.Collection<U>> LazyFutureStream<C>`	`group(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<ListX<U>>`	`grouped(int groupSize)` Group elements in a Stream
`default <C extends java.util.Collection<? super U>> LazyFutureStream<C>`	`grouped(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<ListX<U>>`	`groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit)` Batch elements by size into a List
`default <C extends java.util.Collection<? super U>> LazyFutureStream<C>`	`groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory)` Batch elements by size into a collection created by the supplied factory
`default LazyFutureStream<ListX<U>>`	`groupedByTime(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<? super U>> LazyFutureStream<C>`	`groupedByTime(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<ListX<U>>`	`groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super U>,? super U> predicate)` Create ReactiveSeq of ListX where each ListX is populated while the supplied bipredicate holds.
`default LazyFutureStream<ListX<U>>`	`groupedUntil(java.util.function.Predicate<? super U> predicate)` Create a ReactiveSeq batched by List, where each batch is populated until the predicate holds
`default <C extends java.util.Collection<? super U>> LazyFutureStream<C>`	`groupedUntil(java.util.function.Predicate<? super U> predicate, java.util.function.Supplier<C> factory)` Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
`default LazyFutureStream<ListX<U>>`	`groupedWhile(java.util.function.Predicate<? super U> predicate)` Create a ReactiveSeq batched by List, where each batch is populated while the predicate holds
`default <C extends java.util.Collection<? super U>> LazyFutureStream<C>`	`groupedWhile(java.util.function.Predicate<? super U> predicate, java.util.function.Supplier<C> factory)` Create a ReactiveSeq batched by a Collection, where each batch is populated while the predicate holds
`default 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 <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`innerJoin(java.util.stream.Stream<? extends T> other, java.util.function.BiPredicate<? super U,? super T> predicate)` Inner join 2 streams into one.
`default LazyFutureStream<U>`	`insertAt(int pos, U... values)` Insert data into a stream at given position
`default LazyFutureStream<U>`	`insertStreamAt(int pos, java.util.stream.Stream<U> stream)` Insert a Stream into the middle of this stream at the specified position
`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
`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<? extends T> other, java.util.function.BiPredicate<? super U,? super T> predicate)` Left outer join 2 streams into one.
`default LazyFutureStream<U>`	`limit(long maxSize)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`default LazyFutureStream<U>`	`limit(long time, java.util.concurrent.TimeUnit unit)` Return all elements until specified time period has elapsed
`default LazyFutureStream<U>`	`limitLast(int num)` Limit results to the last x elements in a ReactiveSeq
`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)` Transform this functor using the supplied transformation function
`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)`
`LazyFutureStream<U>`	`maxActive(int concurrentTasks)` Configure the max active concurrent tasks.
`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 LazyFutureStream<U>`	`notNull()` Filter elements retaining only values which are not null
`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<? extends 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<? extends 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<? extends 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<? extends 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<? super SimpleReactFailedStageException,? extends U> fn)` Recover for a particular class of exceptions only.
`default LazyFutureStream<U>`	`onFail(java.util.function.Function<? super SimpleReactFailedStageException,? extends 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<ReactiveSeq<U>,ReactiveSeq<U>>`	`partitionSequence(java.util.function.Predicate<U> splitter)` Partition a Stream into two one a per element basis, based on predicate's boolean value
`default <R> LazyFutureStream<R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<U,R>,Matchable.CheckValue1<U,R>> case1, java.util.function.Supplier<? extends R> otherwise)` 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 at the current value of this Functor, without transforming it
`default LazyFutureStream<U>`	`peekSync(java.util.function.Consumer<? super U> consumer)` Synchronous peek operator
`default LazyFutureStream<ReactiveSeq<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)` Prepend given values to the start of the Stream
`default LazyFutureStream<U>`	`prependStream(java.util.stream.Stream<U> stream)` Prepend Stream to this ReactiveSeq
`default org.jooq.lambda.tuple.Tuple4<ReactiveSeq<U>,ReactiveSeq<U>,ReactiveSeq<U>,ReactiveSeq<U>>`	`quadruplicate()` Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`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)` Recover from a particular exception type
`default LazyFutureStream<U>`	`recover(java.util.function.Function<java.lang.Throwable,? extends U> fn)` Recover from an exception with an alternative value
`default java.util.Optional<U>`	`reduce(java.util.function.BinaryOperator<U> accumulator)`
`default <T> T`	`reduce(T identity, java.util.function.BiFunction<T,? super U,T> accumulator)`
`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<? extends T> other, java.util.function.BiPredicate<? super U,? super T> predicate)` Right outer join 2 streams into one.
`default LazyFutureStream<U>`	`scanLeft(Monoid<U> monoid)` Scan left using supplied Monoid
`default <T> LazyFutureStream<T>`	`scanLeft(T seed, java.util.function.BiFunction<? super T,? super U,? extends T> function)` Scan a stream to the left.
`default LazyFutureStream<U>`	`scanRight(Monoid<U> monoid)` Scan right
`default <R> LazyFutureStream<R>`	`scanRight(R seed, java.util.function.BiFunction<? super U,? super R,? extends 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<? super U,? extends 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)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`default LazyFutureStream<U>`	`skip(long time, java.util.concurrent.TimeUnit unit)` Skip all elements until specified time period has passed
`default LazyFutureStream<U>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`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<ListX<U>>`	`sliding(int size)` Create a sliding view over this Stream
`default LazyFutureStream<ListX<U>>`	`sliding(int size, int increment)` Create a sliding view over this Stream
`default LazyFutureStream<U>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`default LazyFutureStream<U>`	`sorted(java.util.Comparator<? super U> comparator)` `assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));`
`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<ReactiveSeq<U>,ReactiveSeq<U>>`	`splitAt(int where)` Split at supplied location
`default org.jooq.lambda.tuple.Tuple2<ReactiveSeq<U>,ReactiveSeq<U>>`	`splitBy(java.util.function.Predicate<U> splitter)` Split stream at point where predicate no longer holds
`default java.util.Spliterator<U>`	`spliterator()`
`default org.jooq.lambda.tuple.Tuple2<java.util.Optional<U>,ReactiveSeq<U>>`	`splitSequenceAtHead()` Split a Stream at it's head (similar to headAndTail)
`default boolean`	`startsWith(java.util.stream.Stream<U> iterator)` `assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Stream.of(1,2,3)))`
`default boolean`	`startsWithIterable(java.lang.Iterable<U> iterable)` `assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));`
`default ReactiveSeq<U>`	`stream()` Convert this ReactiveSeq into a 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 LazyFutureStream<U>`	`takeRight(int num)`
`default LazyFutureStream<U>`	`takeUntil(java.util.function.Predicate<? super U> p)`
`default LazyFutureStream<U>`	`takeWhile(java.util.function.Predicate<? super U> p)`
`default <R> LazyFutureStream<R>`	`then(java.util.function.Function<? super U,? extends 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<? super U,? extends R> fn, java.util.concurrent.Executor service)`
`default <R> LazyFutureStream<R>`	`thenSync(java.util.function.Function<? super U,? extends 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<ListX<U>>`	`toCompletableFuture()` `CompletableFuture<List<String>> cf = anyM("hello","world") .asSequence() .unwrapCompletableFuture(); assertThat(cf.join(),equalTo(Arrays.asList("hello","world")));`
`default CollectionX<U>`	`toConcurrentLazyCollection()` Lazily converts this ReactiveSeq into a Collection.
`default Streamable<U>`	`toConcurrentLazyStreamable()` { @code Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6).map(i -> i + 2).toConcurrentLazyStreamable(); assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12))); assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12))); }
`default CollectionX<U>`	`toLazyCollection()` Lazily converts this ReactiveSeq into a Collection.
`default java.util.List<U>`	`toList()`
`default java.util.Optional<ListX<U>>`	`toOptional()` `Optional<List<String>> stream = anyM("hello","world") .asSequence() .unwrapOptional(); assertThat(stream.get(),equalTo(Arrays.asList("hello","world")));`
`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()` Convert this ReactiveSeq into a Stream
`default Streamable<U>`	`toStreamable()` `Streamable<Integer> repeat = ReactiveSeq.of(1,2,3,4,5,6) .map(i->i*2) .toStreamable(); repeat.sequenceM().toList(); //Arrays.asList(2,4,6,8,10,12)); repeat.sequenceM().toList() //Arrays.asList(2,4,6,8,10,12));`
`default <R> LazyFutureStream<R>`	`trampoline(java.util.function.Function<? super U,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`default org.jooq.lambda.tuple.Tuple3<ReactiveSeq<U>,ReactiveSeq<U>,ReactiveSeq<U>>`	`triplicate()` Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`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
`LazyFutureStream<U>`	`withAsync(boolean async)`
`<R> LazyFutureStream<R>`	`withLastActive(LazyStreamWrapper<R> streamWrapper)`
`LazyFutureStream<U>`	`withLazyCollector(java.util.function.Supplier<LazyResultConsumer<U>> lazy)`
`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 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(java.lang.Iterable<? extends T> other)`
`default <T,R> LazyFutureStream<R>`	`zip(java.lang.Iterable<? extends T> other, java.util.function.BiFunction<? super U,? super T,? extends R> zipper)`
`default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`zip(org.jooq.lambda.Seq<? extends T> other)` Zip two streams into one.
`default <T,R> LazyFutureStream<R>`	`zip(org.jooq.lambda.Seq<? extends T> other, java.util.function.BiFunction<? super U,? super T,? extends R> zipper)` Zip two streams into one using a `BiFunction` to produce resulting values.
`default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`zip(java.util.stream.Stream<? extends T> other)` Zip 2 streams into one
`default <T,R> LazyFutureStream<R>`	`zip(java.util.stream.Stream<? extends T> other, java.util.function.BiFunction<? super U,? super T,? extends R> zipper)`
`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)` zip 3 Streams into one
`default <T2,T3,T4> LazyFutureStream<org.jooq.lambda.tuple.Tuple4<U,T2,T3,T4>>`	`zip4(java.util.stream.Stream<? extends T2> second, java.util.stream.Stream<? extends T3> third, java.util.stream.Stream<? extends T4> fourth)` zip 4 Streams into 1
`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)` Zip this Monad with a Stream
`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.cyclops.types.futurestream.LazySimpleReactStream
assureSimpleReactException, copySimpleReactStream, filterSync, flatMapToCompletableFuture, flatMapToCompletableFutureSync, getLastActive, handleExceptions, streamCompletableFutures, withErrorHandler

Methods inherited from interface com.aol.cyclops.types.futurestream.ConfigurableStream
getErrorHandler, getRetrier, getTaskExecutor, isAsync

Methods inherited from interface com.aol.cyclops.types.futurestream.BaseSimpleReactStream
getQueueFactory, getTaskExecutor, isAsync, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStreamFrom, simpleReactStreamFromIterable

Methods inherited from interface com.aol.cyclops.types.futurestream.BlockingStream
block, block, getErrorHandler

Methods inherited from interface com.aol.cyclops.types.futurestream.LazyStream
getErrorHandler, getLastActive, getLazyCollector, getMaxActive, run, run, runContinuation, runOnCurrent, runThread

Methods inherited from interface com.aol.cyclops.control.ReactiveSeq
allMatch, anyMatch, append, avg, avg, avgDouble, avgInt, avgLong, collect, collectable, combinations, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, crossJoin, crossJoin, elementAt, foldRight, foldRight, foldRightMapToType, fromDoubleStream, fromIntStream, fromIterable, fromIterator, fromList, fromLongStream, fromPublisher, fromStream, get, groupBy, grouped, grouped, headAndTail, hotStream, innerJoin, innerJoin, innerJoin, join, join, join, leftOuterJoin, leftOuterJoin, leftOuterJoin, limitUntilClosed, mapReduce, mapReduce, max, max, max, max, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, min, minBy, minBy, mode, noneMatch, pausableHotStream, percentile, percentile, percentileBy, percentileBy, prepend, primedHotStream, primedPausableHotStream, print, print, printErr, printOut, range, rangeLong, reduce, reduce, reduce, retry, reversedListOf, reversedOf, rightOuterJoin, rightOuterJoin, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, size, skipUntilClosed, subscriber, sum, sum, sumDouble, sumInt, sumLong, timestamp, toList, toMap, toSet, toString, toString, unfold, unit, unitIterator, unzip, unzip3, unzip4, xMatch

Methods inherited from interface com.aol.cyclops.types.stream.JoolManipulation
removeAll, removeAll, removeAll, removeAll, retainAll, retainAll, retainAll, retainAll

Methods inherited from interface com.aol.cyclops.types.TransformerTraversable
groupedStatefullyWhileT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT

Methods inherited from interface com.aol.cyclops.types.IterableFoldable
visit

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable
bitAnd, bitAnd, bitAndInt, bitAndLong, bitOr, bitOr, bitOrInt, bitOrLong, commonPrefix, commonSuffix, maxAll, maxAll, maxAll, maxAll, maxAllBy, maxAllBy, minAll, minAll, minAll, minAll, minAllBy, minAllBy, modeAll, modeAllBy, modeBy, toMap

Methods inherited from interface com.aol.cyclops.types.stream.JoolWindowing
window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window

Methods inherited from interface org.jooq.lambda.Seq
append, append, append, append, cast, close, concat, concat, concat, concat, concat, concat, concat, contains, containsAll, containsAll, containsAll, containsAll, containsAny, containsAny, containsAny, containsAny, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, cycle, cycle, cycle, cycle, cycle, cycle, cycle, drop, duplicate, findFirst, findSingle, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, format, groupBy, groupBy, groupBy, groupBy, groupBy, grouped, grouped, grouped, grouped, grouped, grouped, intersperse, isEmpty, isNotEmpty, join, join, join, join, join, limit, limitUntil, limitUntilClosed, limitWhile, limitWhileClosed, limitWhileClosed, ofType, partition, prepend, prepend, prepend, prepend, range, range, range, range, range, range, range, range, range, range, range, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, reverse, reverse, reverse, scanLeft, scanLeft, scanLeft, scanRight, scanRight, scanRight, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, skip, skipUntil, skipUntilClosed, skipWhile, skipWhileClosed, skipWhileClosed, slice, sliding, sorted, splitAt, splitAt, splitAtHead, splitAtHead, take, toCollection, toList, toMap, toMap, toSet, toString, toString, transform, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, window, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipWithIndex, zipWithIndex, zipWithIndex

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

Methods inherited from interface com.aol.cyclops.types.applicative.zipping.ZippingApplicativable
ap2, ap3, ap4, ap5

Methods inherited from interface com.aol.cyclops.types.IterableFunctor
flatMapPublisher, flatMapPublisher, flatMapPublisher, mergePublisher, mergePublisher

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

Methods inherited from interface com.aol.cyclops.types.Traversable
lazyOperations, traversable

Methods inherited from interface com.aol.cyclops.types.stream.ConvertableSequence
seq, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary

Methods inherited from interface com.aol.cyclops.types.futurestream.LazyToQueue
add, addToQueue, getPopulator, returnPopulator, toQueue, toQueue

Methods inherited from interface com.aol.cyclops.types.futurestream.ToQueue
getQueueFactory

Methods inherited from interface com.aol.cyclops.types.stream.reactive.FutureStreamSynchronousPublisher
cancel, forwardErrors, getLastActive, subscribeSync

- Method Detail
 - filterNot
```
default LazyFutureStream filterNot(java.util.function.Predicate<? super U> fn)
```
 Description copied from interface: Filterable
 Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
 
 
 of(1,2,3).filter(i->i>2);
 
 //[1,2]
 
 
 
```
 Specified by:
 
 filterNot in interface Filterable
 
 Specified by:
 
 filterNot in interface JoolManipulation
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - notNull
```
default LazyFutureStream notNull()
```
 Description copied from interface: Filterable
 Filter elements retaining only values which are not null
```
 
 
 of(1,2,null,4).nonNull();
 
 //[1,2,4]
 
 
```
 Specified by:
 
 notNull in interface Filterable
 
 Specified by:
 
 notNull in interface JoolManipulation
 
 Returns:
 
 Filterable with nulls removed
 - trampoline
```
default <R> LazyFutureStream<R> trampoline(java.util.function.Function<? super U,? extends Trampoline<? extends R>> mapper)
```
 Description copied from interface: Functor
 Performs a map operation that can call a recursive method without running out of stack space
```
 
 ReactiveSeq.of(10,20,30,40)
				 .trampoline(i-> fibonacci(i))
				 .forEach(System.out::println); 
				 
		Trampoline<Long> fibonacci(int i){
			return fibonacci(i,1,0);
		}
		Trampoline<Long> fibonacci(int n, long a, long b) {
	 	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
		}		 
				 
 55
		6765
		832040
		102334155
 
 
 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
				 .trampoline(i-> fibonacci(i))
				 .forEach(System.out::println);
				 
				 
 completes successfully
 
 
```
 Specified by:
 
 trampoline in interface Functor
 
 Specified by:
 
 trampoline in interface ReactiveSeq
 
 Returns:
 - foldRight
```
default <R> R foldRight(R identity,
 java.util.function.BiFunction<? super U,? super R,? extends R> accumulator)
```
 Specified by:
 
 foldRight in interface Foldable
 
 Specified by:
 
 foldRight in interface ReactiveSeq
 
 Specified by:
 
 foldRight in interface org.jooq.lambda.Seq
 - applicatives
```
default <R> ApplyingZippingApplicativeBuilder<U,R,ZippingApplicativable<R>> applicatives()
```
 Specified by:
 
 applicatives in interface ReactiveSeq
 
 Specified by:
 
 applicatives in interface ZippingApplicativable
 - ap1
```
default <R> ZippingApplicativable<R> ap1(java.util.function.Function<? super U,? extends R> fn)
```
 Specified by:
 
 ap1 in interface ReactiveSeq
 
 Specified by:
 
 ap1 in interface ZippingApplicativable
 - 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 ReactiveSeq
 
 Returns:
 
 LazyFutureStream that adds the time between elements in millis to each element
 - combine
```
default LazyFutureStream combine(java.util.function.BiPredicate<? super U,? super U> predicate,
 java.util.function.BinaryOperator op)
```
 Description copied from interface: Traversable
 Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping & reduction operation. The output of a combination may in turn be combined with it's neighbour
```
 
 ReactiveSeq.of(1,1,2,3)
 .combine((a, b)->a.equals(b),Semigroups.intSum)
 .toListX()
 
 //ListX(3,4) 
 
```
 Specified by:
 
 combine in interface ReactiveSeq
 
 Specified by:
 
 combine in interface Traversable
 
 Parameters:
 
 predicate - Test to see if two neighbours should be joined
 
 op - Reducer to combine neighbours
 
 Returns:
 
 Combined / Partially Reduced Traversable
 - onEmptySwitch
```
default LazyFutureStream onEmptySwitch(java.util.function.Supplier<? extends java.util.stream.Stream> switchTo)
```
 If this SequenceM is empty replace it with a another Stream
```
 
 assertThat(LazyFutureStream.of(4,5,6)
 							.onEmptySwitch(()->ReactiveSeq.of(1,2,3))
 							.toList(),
 							equalTo(Arrays.asList(4,5,6)));
 
 
```
 Specified by:
 
 onEmptySwitch in interface ReactiveSeq
 
 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 ReactiveSeq
 
 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 ReactiveSeq
 
 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 ReactiveSeq
 
 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 ReactiveSeq
 
 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(java.util.function.Function<Matchable.CheckValue1<U,R>,Matchable.CheckValue1<U,R>> case1,
 java.util.function.Supplier<? extends R> otherwise)
```
 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"]
 
```
 Specified by:
 
 patternMatch in interface Functor
 
 Specified by:
 
 patternMatch in interface ReactiveSeq
 
 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
 - 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 ReactiveSeq
 
 Specified by:
 
 remove in interface org.jooq.lambda.Seq
 
 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 ReactiveSeq
 
 Parameters:
 
 start - index inclusive
 
 end - index exclusive
 
 Returns:
 
 LqzyFutureStream between supplied indexes of original Sequence
 - permutations
```
default LazyFutureStream<ReactiveSeq> 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 ExtendedTraversable
 
 Specified by:
 
 permutations in interface ReactiveSeq
 
 Returns:
 
 Permutations from this LazyFutureStream
 - combinations
```
default LazyFutureStream<ReactiveSeq> 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 ExtendedTraversable
 
 Specified by:
 
 combinations in interface ReactiveSeq
 
 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 FutureStreamSynchronousPublisher
 
 Specified by:
 
 subscribe in interface org.reactivestreams.Publisher
 
 Specified by:
 
 subscribe in interface Traversable
 - 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.Collectable
 
 Specified by:
 
 count in interface CyclopsCollectable
 
 Specified by:
 
 count in interface ReactiveSeq
 
 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 FutureStreamSynchronousPublisher
 
 Specified by:
 
 toQueue in interface LazyToQueue
 
 Specified by:
 
 toQueue in interface ToQueue
 
 Returns:
 
 Data in a queue
 - reduce
```
default <T> T reduce(T identity,
 java.util.function.BiFunction<T,? super U,T> accumulator)
```
 Specified by:
 
 reduce in interface Foldable
 
 Specified by:
 
 reduce in interface LazyStream
 - reduce
```
default U reduce(U identity,
 java.util.function.BinaryOperator accumulator)
```
 Specified by:
 
 reduce in interface Foldable
 
 Specified by:
 
 reduce in interface LazyStream
 
 Specified by:
 
 reduce in interface ReactiveSeq
 
 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 Foldable
 
 Specified by:
 
 reduce in interface LazyStream
 
 Specified by:
 
 reduce in interface ReactiveSeq
 
 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 Foldable
 
 Specified by:
 
 reduce in interface LazyStream
 
 Specified by:
 
 reduce in interface ReactiveSeq
 
 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<? super U,? extends 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.
 - hotStream
```
default 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
 - findFirst
```
default java.util.Optional findFirst()
```
 Specified by:
 
 findFirst in interface Foldable
 
 Specified by:
 
 findFirst in interface ReactiveSeq
 
 Specified by:
 
 findFirst in interface java.util.stream.Stream
 
 Returns:
 First matching element in sequential order
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findFirst().get(); //3
 (deterministic)
 - 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)
```
 Description copied from interface: Functor
 Transform this functor using the supplied transformation function
```
 
 
 
 of(1,2,3).map(i->i*2)
 
 //[2,4,6]
 
 
 
```
 Specified by:
 
 map in interface FilterableFunctor
 
 Specified by:
 
 map in interface Functor
 
 Specified by:
 
 map in interface IterableFunctor
 
 Specified by:
 
 map in interface ReactiveSeq
 
 Specified by:
 
 map in interface org.jooq.lambda.Seq
 
 Specified by:
 
 map in interface java.util.stream.Stream
 
 Parameters:
 
 mapper - Transformation function
 
 Returns:
 
 Transformed Functor
 - shard
```
default <K> java.util.Map<K,LazyFutureStream> shard(java.util.Map<K,Queue> shards,
 java.util.function.Function<? super U,? extends 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 ReactiveSeq
 
 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
 - group
```
default <C extends java.util.Collection> LazyFutureStream<C> group(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
 - groupedBySizeAndTime
```
default LazyFutureStream<ListX> groupedBySizeAndTime(int size,
 long time,
 java.util.concurrent.TimeUnit unit)
```
 Description copied from interface: ReactiveSeq
 Batch elements by size into a List
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .batchBySizeAndTime(3,10,TimeUnit.SECONDS)
 .toList();
 
 //[[1,2,3],[4,5,6]] 
 
```
 Specified by:
 
 groupedBySizeAndTime in interface ReactiveSeq
 
 Parameters:
 
 size - Max size of a batch
 
 time - (Max) time period to build a single batch in
 
 unit - time unit for batch
 
 Returns:
 
 ReactiveSeq batched by size and time
 - grouped
```
default <C extends java.util.Collection<? super U>> LazyFutureStream<C> grouped(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:
 
 grouped in interface ReactiveSeq
 
 Specified by:
 
 grouped in interface Traversable
 
 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 ReactiveSeq
 
 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 ReactiveSeq
 
 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 ReactiveSeq
 
 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 ReactiveSeq
 
 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
 - groupedByTime
```
default LazyFutureStream<ListX> groupedByTime(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:
 
 groupedByTime in interface ReactiveSeq
 
 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
 - groupedByTime
```
default <C extends java.util.Collection<? super U>> LazyFutureStream<C> groupedByTime(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:
 
 groupedByTime in interface ReactiveSeq
 
 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<? super U,? extends 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<? super U,? extends 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<? super SimpleReactFailedStageException,? extends 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<? super SimpleReactFailedStageException,? extends 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<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: Functor
 Peek at the current value of this Functor, without transforming it
```
 
 
 
 of(1,2,3).map(System.out::println)
 
 1
 2
 3
 
 
 
```
 Specified by:
 
 peek in interface BaseSimpleReactStream
 
 Specified by:
 
 peek in interface Functor
 
 Specified by:
 
 peek in interface LazySimpleReactStream
 
 Specified by:
 
 peek in interface ReactiveSeq
 
 Specified by:
 
 peek in interface org.jooq.lambda.Seq
 
 Specified by:
 
 peek in interface java.util.stream.Stream
 
 Parameters:
 
 consumer - Consumer that recieves each element from this Functor
 
 Returns:
 
 Functor that will peek at each value
 - filter
```
default LazyFutureStream filter(java.util.function.Predicate<? super U> p)
```
 Description copied from interface: Filterable
 Keep only elements for which the supplied predicates hold e.g.
```
 
 
 of(1,2,3).filter(i->i>2);
 
 //[3]
 
 
 
```
 Specified by:
 
 filter in interface BaseSimpleReactStream
 
 Specified by:
 
 filter in interface Filterable
 
 Specified by:
 
 filter in interface FilterableFunctor
 
 Specified by:
 
 filter in interface JoolManipulation
 
 Specified by:
 
 filter in interface LazySimpleReactStream
 
 Specified by:
 
 filter in interface ReactiveSeq
 
 Specified by:
 
 filter in interface org.jooq.lambda.Seq
 
 Specified by:
 
 filter in interface java.util.stream.Stream
 
 Parameters:
 
 p - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - 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 ReactiveSeq
 
 Specified by:
 
 flatMap in interface org.jooq.lambda.Seq
 
 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
 - flatMapAnyM
```
default <R> LazyFutureStream<R> flatMapAnyM(java.util.function.Function<? super U,AnyM<? extends R>> flatFn)
```
 Description copied from interface: ReactiveSeq
 Allows flatMap return type to be any Monad type
```
 
 	assertThat(ReactiveSeq.of(1,2,3)).flatMapAnyM(i-> anyM(CompletableFuture.completedFuture(i+2))).toList(),equalTo(Arrays.asList(3,4,5)));
 
 
 
```
 Specified by:
 
 flatMapAnyM in interface ReactiveSeq
 
 Parameters:
 
 flatFn - to be applied
 
 Returns:
 
 new stage in Sequence with flatMap operation to be lazily applied
 - 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
 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 ReactiveSeq
 
 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<? extends U> 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 ReactiveSeq
 
 Specified by:
 
 concat in interface org.jooq.lambda.Seq
 
 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 ReactiveSeq
 
 Specified by:
 
 concat in interface org.jooq.lambda.Seq
 
 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 ReactiveSeq
 
 Specified by:
 
 concat in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.concat(Stream[])
 - cast
```
default  LazyFutureStream cast(java.lang.Class<? extends U> type)
```
 Description copied from interface: Functor
 
 Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)
 
 Specified by:
 
 cast in interface BaseSimpleReactStream
 
 Specified by:
 
 cast in interface Functor
 
 Specified by:
 
 cast in interface ReactiveSeq
 
 Specified by:
 
 cast in interface org.jooq.lambda.Seq
 - ofType
```
default  LazyFutureStream ofType(java.lang.Class<? extends U> 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 Filterable
 
 Specified by:
 
 ofType in interface JoolManipulation
 
 Specified by:
 
 ofType in interface ReactiveSeq
 
 Specified by:
 
 ofType in interface org.jooq.lambda.Seq
 - 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 ReactiveSeq
 
 Specified by:
 
 intersperse in interface org.jooq.lambda.Seq
 
 Specified by:
 
 intersperse in interface Traversable
 
 See Also:
 
 Seq.intersperse(Stream, Object)
 - limit
```
default LazyFutureStream limit(long maxSize)
```
 Description copied from interface: ReactiveSeq
```
 assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
 
```
 Specified by:
 
 limit in interface ReactiveSeq
 
 Specified by:
 
 limit in interface org.jooq.lambda.Seq
 
 Specified by:
 
 limit in interface java.util.stream.Stream
 
 Specified by:
 
 limit in interface Traversable
 
 Parameters:
 
 maxSize - Limit element size to num
 
 Returns:
 
 Monad converted to Stream with elements up to num
 - takeWhile
```
default LazyFutureStream takeWhile(java.util.function.Predicate<? super U> p)
```
 Specified by:
 
 takeWhile in interface ReactiveSeq
 
 Specified by:
 
 takeWhile in interface Traversable
 - dropWhile
```
default LazyFutureStream dropWhile(java.util.function.Predicate<? super U> p)
```
 Specified by:
 
 dropWhile in interface ReactiveSeq
 
 Specified by:
 
 dropWhile in interface Traversable
 - takeUntil
```
default LazyFutureStream takeUntil(java.util.function.Predicate<? super U> p)
```
 Specified by:
 
 takeUntil in interface ReactiveSeq
 
 Specified by:
 
 takeUntil in interface Traversable
 - dropUntil
```
default LazyFutureStream dropUntil(java.util.function.Predicate<? super U> p)
```
 Specified by:
 
 dropUntil in interface ReactiveSeq
 
 Specified by:
 
 dropUntil in interface Traversable
 - dropRight
```
default LazyFutureStream dropRight(int num)
```
 Specified by:
 
 dropRight in interface ReactiveSeq
 
 Specified by:
 
 dropRight in interface Traversable
 - takeRight
```
default LazyFutureStream takeRight(int num)
```
 Specified by:
 
 takeRight in interface ReactiveSeq
 
 Specified by:
 
 takeRight in interface Traversable
 - skip
```
default LazyFutureStream skip(long n)
```
 Description copied from interface: ReactiveSeq
```
 assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
 Specified by:
 
 skip in interface BaseSimpleReactStream
 
 Specified by:
 
 skip in interface ReactiveSeq
 
 Specified by:
 
 skip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 skip in interface java.util.stream.Stream
 
 Specified by:
 
 skip in interface Traversable
 
 Parameters:
 
 n - Number of elemenets to skip
 
 Returns:
 
 Stream with specified number of elements skipped
 - distinct
```
default LazyFutureStream distinct()
```
 Specified by:
 
 distinct in interface ReactiveSeq
 
 Specified by:
 
 distinct in interface org.jooq.lambda.Seq
 
 Specified by:
 
 distinct in interface java.util.stream.Stream
 
 Specified by:
 
 distinct in interface Traversable
 - sliding
```
default LazyFutureStream<ListX> 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 ReactiveSeq
 
 Specified by:
 
 sliding in interface Traversable
 
 Parameters:
 
 size - Size of sliding window
 
 Returns:
 
 Stream with sliding view over data in this stream
 - sliding
```
default LazyFutureStream<ListX> 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 ReactiveSeq
 
 Specified by:
 
 sliding in interface Traversable
 
 Parameters:
 
 size - Size of sliding window
 
 increment - for each 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 ReactiveSeq
 
 Specified by:
 
 slice in interface org.jooq.lambda.Seq
 
 Specified by:
 
 slice in interface Traversable
 - 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 ReactiveSeq
 
 Specified by:
 
 zipWithIndex in interface org.jooq.lambda.Seq
 
 Specified by:
 
 zipWithIndex in interface Traversable
 
 See Also:
 
 Seq.zipWithIndex(Stream)
 - zip
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> zip(org.jooq.lambda.Seq<? extends 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 ReactiveSeq
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 zip in interface Traversable
 
 See Also:
 
 Seq.zip(Stream, Stream)
 - zip
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> zip(java.util.stream.Stream<? extends T> other)
```
 Description copied from interface: ReactiveSeq
 Zip 2 streams into one
```
 {
 @code
 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
 // [[1,"a"],[2,"b"]]
 }
 
```
 Specified by:
 
 zip in interface ReactiveSeq
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 zip in interface Traversable
 - zip
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> zip(java.lang.Iterable<? extends T> other)
```
 Specified by:
 
 zip in interface ReactiveSeq
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 zip in interface Traversable
 - zip
```
default <T,R> LazyFutureStream<R> zip(org.jooq.lambda.Seq<? extends T> other,
 java.util.function.BiFunction<? super U,? super T,? extends 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 ReactiveSeq
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 zip in interface Traversable
 
 See Also:
 
 zip(Seq, BiFunction)
 - zip
```
default <T,R> LazyFutureStream<R> zip(java.util.stream.Stream<? extends T> other,
 java.util.function.BiFunction<? super U,? super T,? extends R> zipper)
```
 Specified by:
 
 zip in interface ReactiveSeq
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 zip in interface Traversable
 - zip
```
default <T,R> LazyFutureStream<R> zip(java.lang.Iterable<? extends T> other,
 java.util.function.BiFunction<? super U,? super T,? extends R> zipper)
```
 Specified by:
 
 zip in interface ReactiveSeq
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 zip in interface Traversable
 - scanLeft
```
default <T> LazyFutureStream<T> scanLeft(T seed,
 java.util.function.BiFunction<? super T,? super U,? extends 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 ReactiveSeq
 
 Specified by:
 
 scanLeft in interface org.jooq.lambda.Seq
 
 Specified by:
 
 scanLeft in interface Traversable
 - scanRight
```
default <R> LazyFutureStream<R> scanRight(R seed,
 java.util.function.BiFunction<? super U,? super R,? extends 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 ReactiveSeq
 
 Specified by:
 
 scanRight in interface org.jooq.lambda.Seq
 
 Specified by:
 
 scanRight in interface Traversable
 - scanRight
```
default LazyFutureStream scanRight(Monoid monoid)
```
 Description copied from interface: ReactiveSeq
 Scan right
```
 
 assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
 is(asList("", "c", "bc", "abc").size()));
 
 
```
 Specified by:
 
 scanRight in interface ReactiveSeq
 
 Specified by:
 
 scanRight in interface Traversable
 - reverse
```
default LazyFutureStream reverse()
```
 Reverse a stream. - eager operation that materializes the Stream into a list - careful with infinite streams! // (3, 2, 1) LazyFutureStream.of(1, 2, 3).reverse()
 
 Specified by:
 
 reverse in interface ReactiveSeq
 
 Specified by:
 
 reverse in interface org.jooq.lambda.Seq
 
 Specified by:
 
 reverse in interface Traversable
 - shuffle
```
default LazyFutureStream shuffle()
```
 Shuffle a stream // e.g. (2, 3, 1) LazyFutureStream.of(1, 2, 3).shuffle()
 
 Specified by:
 
 shuffle in interface ReactiveSeq
 
 Specified by:
 
 shuffle in interface org.jooq.lambda.Seq
 
 Specified by:
 
 shuffle in interface Traversable
 - 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 ReactiveSeq
 
 Specified by:
 
 shuffle in interface org.jooq.lambda.Seq
 
 Specified by:
 
 shuffle in interface Traversable
 - 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 ReactiveSeq
 
 Specified by:
 
 skipWhile in interface org.jooq.lambda.Seq
 
 Specified by:
 
 skipWhile in interface Traversable
 
 Parameters:
 
 predicate - Predicate to skip while true
 
 Returns:
 
 Stream with elements skipped while predicate holds
 
 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 ReactiveSeq
 
 Specified by:
 
 skipUntil in interface org.jooq.lambda.Seq
 
 Specified by:
 
 skipUntil in interface Traversable
 
 Parameters:
 
 predicate - Predicate to skip until true
 
 Returns:
 
 Stream with elements skipped until predicate holds
 
 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 ReactiveSeq
 
 Specified by:
 
 limitWhile in interface org.jooq.lambda.Seq
 
 Specified by:
 
 limitWhile in interface Traversable
 
 Parameters:
 
 predicate - Limit while predicate is true
 
 Returns:
 
 Stream with limited elements
 
 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 ReactiveSeq
 
 Specified by:
 
 limitUntil in interface org.jooq.lambda.Seq
 
 Specified by:
 
 limitUntil in interface Traversable
 
 Parameters:
 
 predicate - Limit until predicate is true
 
 Returns:
 
 Stream with limited elements
 
 See Also:
 
 Seq.limitUntil(Stream, Predicate)
 - crossJoin
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> crossJoin(java.util.stream.Stream<? extends 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 ReactiveSeq
 
 Specified by:
 
 crossJoin in interface org.jooq.lambda.Seq
 - 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 ReactiveSeq
 
 Specified by:
 
 onEmpty in interface org.jooq.lambda.Seq
 
 Specified by:
 
 onEmpty in interface Traversable
 - onEmptyGet
```
default LazyFutureStream onEmptyGet(java.util.function.Supplier<? extends U> 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 ReactiveSeq
 
 Specified by:
 
 onEmptyGet in interface org.jooq.lambda.Seq
 
 Specified by:
 
 onEmptyGet in interface Traversable
 - onEmptyThrow
```
default <X extends java.lang.Throwable> LazyFutureStream onEmptyThrow(java.util.function.Supplier<? extends 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 ReactiveSeq
 
 Specified by:
 
 onEmptyThrow in interface org.jooq.lambda.Seq
 
 Specified by:
 
 onEmptyThrow in interface Traversable
 - innerJoin
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> innerJoin(java.util.stream.Stream<? extends T> other,
 java.util.function.BiPredicate<? super U,? super 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 ReactiveSeq
 
 Specified by:
 
 innerJoin in interface org.jooq.lambda.Seq
 - leftOuterJoin
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> leftOuterJoin(java.util.stream.Stream<? extends T> other,
 java.util.function.BiPredicate<? super U,? super 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 ReactiveSeq
 
 Specified by:
 
 leftOuterJoin in interface org.jooq.lambda.Seq
 - rightOuterJoin
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> rightOuterJoin(java.util.stream.Stream<? extends T> other,
 java.util.function.BiPredicate<? super U,? super 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 ReactiveSeq
 
 Specified by:
 
 rightOuterJoin in interface org.jooq.lambda.Seq
 - 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 ReactiveSeq
 
 Specified by:
 
 cycle in interface org.jooq.lambda.Seq
 
 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 ReactiveSeq
 
 Specified by:
 
 cycle in interface Traversable
 
 Parameters:
 
 times - Times values should be repeated within a Stream
 
 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 ReactiveSeq
 
 Specified by:
 
 cycleWhile in interface Traversable
 
 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 ReactiveSeq
 
 Specified by:
 
 cycleUntil in interface Traversable
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - foldable
```
default IterableFoldable foldable()
```
 Specified by:
 
 foldable in interface Foldable
 
 Specified by:
 
 foldable in interface IterableFoldable
 - stream
```
default ReactiveSeq stream()
```
 Description copied from interface: ReactiveSeq
 
 Convert this ReactiveSeq into a Stream
 
 Specified by:
 
 stream in interface ConvertableSequence
 
 Specified by:
 
 stream in interface ExtendedTraversable
 
 Specified by:
 
 stream in interface Foldable
 
 Specified by:
 
 stream in interface IterableFunctor
 
 Specified by:
 
 stream in interface ReactiveSeq
 
 Specified by:
 
 stream in interface org.jooq.lambda.Seq
 
 Specified by:
 
 stream in interface TransformerTraversable
 
 Specified by:
 
 stream in interface Traversable
 - parallel
```
default LazyFutureStream parallel()
```
 Specified by:
 
 parallel in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 parallel in interface ReactiveSeq
 
 Specified by:
 
 parallel in interface org.jooq.lambda.Seq
 
 Returns:
 
 Does nothing ReactiveSeq is for Sequential Streams
 - sequential
```
default LazyFutureStream sequential()
```
 Specified by:
 
 sequential in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 sequential in interface ReactiveSeq
 
 Specified by:
 
 sequential in interface org.jooq.lambda.Seq
 - unordered
```
default LazyFutureStream unordered()
```
 Specified by:
 
 unordered in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 unordered in interface ReactiveSeq
 
 Specified by:
 
 unordered in interface org.jooq.lambda.Seq
 - onClose
```
default LazyFutureStream onClose(java.lang.Runnable closeHandler)
```
 Specified by:
 
 onClose in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 onClose in interface ReactiveSeq
 
 Specified by:
 
 onClose in interface org.jooq.lambda.Seq
 - sorted
```
default LazyFutureStream sorted()
```
 Description copied from interface: ReactiveSeq
```
 assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); 
 
```
 Specified by:
 
 sorted in interface ReactiveSeq
 
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq
 
 Specified by:
 
 sorted in interface java.util.stream.Stream
 
 Specified by:
 
 sorted in interface Traversable
 - sorted
```
default LazyFutureStream sorted(java.util.Comparator<? super U> comparator)
```
 Description copied from interface: ReactiveSeq
```
 
 	assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
 
 
```
 Specified by:
 
 sorted in interface ReactiveSeq
 
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq
 
 Specified by:
 
 sorted in interface java.util.stream.Stream
 
 Specified by:
 
 sorted in interface Traversable
 
 Parameters:
 
 comparator - Compartor to sort with
 
 Returns:
 
 Sorted 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 ReactiveSeq
 
 Specified by:
 
 unwrap in interface Unwrapable
 
 Returns:
 
 wrapped value
 - flatten
```
default <T1> LazyFutureStream<T1> flatten()
```
 Description copied from interface: ReactiveSeq
 join / flatten one level of a nested hierarchy
```
 
 ReactiveSeq.of(Arrays.asList(1,2)).flatten();
 
 //stream of (1, 2);		
 
 
 
 
 
 
```
 Specified by:
 
 flatten in interface ReactiveSeq
 
 Returns:
 
 Flattened / joined one level
 - toOptional
```
default java.util.Optional<ListX> toOptional()
```
 Description copied from interface: ConvertableSequence
```
 
 Optional<List<String>> stream = anyM("hello","world")
											.asSequence()
											.unwrapOptional();
		assertThat(stream.get(),equalTo(Arrays.asList("hello","world")));
 
 
 
```
 Specified by:
 
 toOptional in interface ConvertableSequence
 
 Returns:
 - toCompletableFuture
```
default java.util.concurrent.CompletableFuture<ListX> toCompletableFuture()
```
 Description copied from interface: ConvertableSequence
```
 
 CompletableFuture<List<String>> cf = anyM("hello","world")
											.asSequence()
											.unwrapCompletableFuture();
		assertThat(cf.join(),equalTo(Arrays.asList("hello","world")));
 
 
```
 Specified by:
 
 toCompletableFuture in interface ConvertableSequence
 
 Returns:
 - 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
 - findAny
```
default java.util.Optional findAny()
```
 Specified by:
 
 findAny in interface Foldable
 
 Specified by:
 
 findAny in interface ReactiveSeq
 
 Specified by:
 
 findAny in interface java.util.stream.Stream
 
 Returns:
 first matching element, but order is not guaranteed
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findAny().get(); //3
 (non-deterministic)
 - toSet
```
default java.util.Set toSet()
```
 Specified by:
 
 toSet in interface org.jooq.lambda.Collectable
 
 Specified by:
 
 toSet in interface CyclopsCollectable
 
 Specified by:
 
 toSet in interface ReactiveSeq
 
 Returns:
 
 This Stream converted to a set
 - toList
```
default java.util.List toList()
```
 Specified by:
 
 toList in interface org.jooq.lambda.Collectable
 
 Specified by:
 
 toList in interface CyclopsCollectable
 
 Specified by:
 
 toList in interface ReactiveSeq
 
 Returns:
 
 this Stream converted to a list
 - toCollection
```
default <C extends java.util.Collection> C toCollection(java.util.function.Supplier<C> collectionFactory)
```
 Specified by:
 
 toCollection in interface org.jooq.lambda.Collectable
 
 Specified by:
 
 toCollection in interface CyclopsCollectable
 
 Specified by:
 
 toCollection in interface ReactiveSeq
 - distinct
```
default <R> ReactiveSeq distinct(java.util.function.Function<? super U,? extends R> keyExtractor)
```
 Specified by:
 
 distinct in interface ReactiveSeq
 
 Specified by:
 
 distinct in interface org.jooq.lambda.Seq
 - duplicateSequence
```
default org.jooq.lambda.tuple.Tuple2<ReactiveSeq,ReactiveSeq> duplicateSequence()
```
 Description copied from interface: ReactiveSeq
 Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.
```
 {
 @code
 Tuple2<ReactiveSeq<Integer>, ReactiveSeq<Integer>> copies = of(1, 2, 3, 4, 5, 6).duplicate();
 assertTrue(copies.v1.anyMatch(i -> i == 2));
 assertTrue(copies.v2.anyMatch(i -> i == 2));
 
 }
 
```
 Specified by:
 
 duplicateSequence in interface ReactiveSeq
 
 Returns:
 
 duplicated stream
 - triplicate
```
default org.jooq.lambda.tuple.Tuple3<ReactiveSeq,ReactiveSeq,ReactiveSeq> triplicate()
```
 Description copied from interface: ReactiveSeq
 Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.
```
 {
 @code
 Tuple3<ReactiveSeq<Tuple3<T1, T2, T3>>, ReactiveSeq<Tuple3<T1, T2, T3>>, ReactiveSeq<Tuple3<T1, T2, T3>>> Tuple3 = sequence.triplicate();
 
 }
 
```
 Specified by:
 
 triplicate in interface ReactiveSeq
 - quadruplicate
```
default org.jooq.lambda.tuple.Tuple4<ReactiveSeq,ReactiveSeq,ReactiveSeq,ReactiveSeq> quadruplicate()
```
 Description copied from interface: ReactiveSeq
 Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.
```
 {
 @code
 Tuple4<ReactiveSeq<Tuple4<T1, T2, T3, T4>>, ReactiveSeq<Tuple4<T1, T2, T3, T4>>, ReactiveSeq<Tuple4<T1, T2, T3, T4>>, ReactiveSeq<Tuple4<T1, T2, T3, T4>>> quad = sequence
 .quadruplicate();
 
 }
 
```
 Specified by:
 
 quadruplicate in interface ReactiveSeq
 
 Returns:
 - splitSequenceAtHead
```
default org.jooq.lambda.tuple.Tuple2<java.util.Optional,ReactiveSeq> splitSequenceAtHead()
```
 Description copied from interface: ReactiveSeq
 Split a Stream at it's head (similar to headAndTail)
```
 
 ReactiveSeq.of(1,2,3).splitAtHead()
 
 //Optional[1], ReactiveSeq[2,3]
 
 
 
```
 Specified by:
 
 splitSequenceAtHead in interface ReactiveSeq
 - splitAt
```
default org.jooq.lambda.tuple.Tuple2<ReactiveSeq,ReactiveSeq> splitAt(int where)
```
 Description copied from interface: ReactiveSeq
 Split at supplied location
```
 
 ReactiveSeq.of(1,2,3).splitAt(1)
 
 //ReactiveSeq[1], ReactiveSeq[2,3]
 
 
 
```
 Specified by:
 
 splitAt in interface ReactiveSeq
 - splitBy
```
default org.jooq.lambda.tuple.Tuple2<ReactiveSeq,ReactiveSeq> splitBy(java.util.function.Predicate splitter)
```
 Description copied from interface: ReactiveSeq
 Split stream at point where predicate no longer holds
```
 
 ReactiveSeq.of(1, 2, 3, 4, 5, 6).splitBy(i->i<4)
 
 //ReactiveSeq[1,2,3] ReactiveSeq[4,5,6]
 
 
```
 Specified by:
 
 splitBy in interface ReactiveSeq
 - partitionSequence
```
default org.jooq.lambda.tuple.Tuple2<ReactiveSeq,ReactiveSeq> partitionSequence(java.util.function.Predicate splitter)
```
 Description copied from interface: ReactiveSeq
 Partition a Stream into two one a per element basis, based on predicate's boolean value
```
 
 ReactiveSeq.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0) 
 
 //ReactiveSeq[1,3,5], ReactiveSeq[2,4,6]
 

 
```
 Specified by:
 
 partitionSequence in interface ReactiveSeq
 - cycle
```
default LazyFutureStream cycle(Monoid m,
 int times)
```
 Description copied from interface: ReactiveSeq
 Convert to a Stream with the result of a reduction operation repeated specified times
```
 
 List<Integer> list = ReactiveSeq.of(1,2,2))
 .cycle(Reducers.toCountInt(),3)
 .collect(Collectors.toList());
 //List[3,3,3];
 
 
```
 Specified by:
 
 cycle in interface ReactiveSeq
 
 Specified by:
 
 cycle in interface Traversable
 
 Parameters:
 
 m - Monoid to be used in reduction
 
 times - Number of times value should be repeated
 
 Returns:
 
 Stream with reduced values repeated
 - 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)
```
 Description copied from interface: ReactiveSeq
 zip 3 Streams into one
```
 {
 @code
 List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(Collectors.toList());
 
 // [[1,100,'a'],[2,200,'b'],[3,300,'c']]
 }
 
 
```
 Specified by:
 
 zip3 in interface ReactiveSeq
 
 Specified by:
 
 zip3 in interface Traversable
 - zip4
```
default <T2,T3,T4> LazyFutureStream<org.jooq.lambda.tuple.Tuple4<U,T2,T3,T4>> zip4(java.util.stream.Stream<? extends T2> second,
 java.util.stream.Stream<? extends T3> third,
 java.util.stream.Stream<? extends T4> fourth)
```
 Description copied from interface: ReactiveSeq
 zip 4 Streams into 1
```
 {
 @code
 List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
 .collect(Collectors.toList());
 
 }
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 
```
 Specified by:
 
 zip4 in interface ReactiveSeq
 
 Specified by:
 
 zip4 in interface Traversable
 - 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)
```
 Description copied from interface: ReactiveSeq
 Zip this Monad with a Stream
```
 {
 @code
 Stream<List<Integer>> zipped = asMonad(Stream.of(1, 2, 3)).zip(Stream.of(2, 3, 4), (a, b) -> Arrays.asList(a, b));
 
 // [[1,2][2,3][3,4]]
 }
 
```
 Specified by:
 
 zipStream in interface ReactiveSeq
 
 Parameters:
 
 second - Stream to zip with
 
 zipper - Zip funciton
 
 Returns:
 
 This monad zipped with a Stream
 - grouped
```
default LazyFutureStream<ListX> grouped(int groupSize)
```
 Description copied from interface: ReactiveSeq
 Group elements in a Stream
```
 {
 @code
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(4, 5, 6));
 
 }
 
```
 Specified by:
 
 grouped in interface ReactiveSeq
 
 Specified by:
 
 grouped in interface Traversable
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - scanLeft
```
default LazyFutureStream scanLeft(Monoid monoid)
```
 Description copied from interface: ReactiveSeq
 Scan left using supplied Monoid
```
 
 
 	assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
 													.scanLeft(Reducers.toString("")).toList());
 
 
 
```
 Specified by:
 
 scanLeft in interface ReactiveSeq
 
 Specified by:
 
 scanLeft in interface Traversable
 
 Returns:
 - toStreamable
```
default Streamable toStreamable()
```
 Description copied from interface: ReactiveSeq
```
 
 	Streamable<Integer> repeat = ReactiveSeq.of(1,2,3,4,5,6)
 												.map(i->i*2)
 												.toStreamable();
 		
 		repeat.sequenceM().toList(); //Arrays.asList(2,4,6,8,10,12));
 		repeat.sequenceM().toList() //Arrays.asList(2,4,6,8,10,12));
 
 
```
 Specified by:
 
 toStreamable in interface ConvertableSequence
 
 Specified by:
 
 toStreamable in interface ReactiveSeq
 
 Returns:
 
 Lazily Convert to a repeatable Streamable
 - toStream
```
default  java.util.stream.Stream toStream()
```
 Description copied from interface: ReactiveSeq
 
 Convert this ReactiveSeq into a Stream
 
 Specified by:
 
 toStream in interface ReactiveSeq
 
 Returns:
 
 calls to stream() but more flexible on type for inferencing purposes.
 - startsWithIterable
```
default boolean startsWithIterable(java.lang.Iterable iterable)
```
 Description copied from interface: ReactiveSeq
```
 
 assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));
 
 
```
 Specified by:
 
 startsWithIterable in interface Foldable
 
 Specified by:
 
 startsWithIterable in interface ReactiveSeq
 
 Returns:
 
 True if Monad starts with Iterable sequence of data
 - startsWith
```
default boolean startsWith(java.util.stream.Stream iterator)
```
 Description copied from interface: ReactiveSeq
```
 assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Stream.of(1,2,3))) 
 
```
 Specified by:
 
 startsWith in interface Foldable
 
 Specified by:
 
 startsWith in interface ReactiveSeq
 
 Returns:
 
 True if Monad starts with Iterators sequence of data
 - endsWithIterable
```
default boolean endsWithIterable(java.lang.Iterable iterable)
```
 Description copied from interface: ReactiveSeq
```
 
 assertTrue(ReactiveSeq.of(1,2,3,4,5,6)
 				.endsWith(Arrays.asList(5,6)));
 
 
```
 Specified by:
 
 endsWithIterable in interface Foldable
 
 Specified by:
 
 endsWithIterable in interface ReactiveSeq
 
 Parameters:
 
 iterable - Values to check
 
 Returns:
 
 true if ReactiveSeq ends with values in the supplied iterable
 - endsWith
```
default boolean endsWith(java.util.stream.Stream stream)
```
 Description copied from interface: ReactiveSeq
```
 
 assertTrue(ReactiveSeq.of(1,2,3,4,5,6)
 				.endsWith(Stream.of(5,6))); 
 
 
```
 Specified by:
 
 endsWith in interface Foldable
 
 Specified by:
 
 endsWith in interface ReactiveSeq
 
 Parameters:
 
 stream - Values to check
 
 Returns:
 
 true if ReactiveSeq endswith values in the supplied Stream
 - anyM
```
default AnyMSeq anyM()
```
 Specified by:
 
 anyM in interface ReactiveSeq
 
 Returns:
 
 this ReactiveSeq converted to AnyM format
 - flatMapIterable
```
default <R> LazyFutureStream<R> flatMapIterable(java.util.function.Function<? super U,? extends java.lang.Iterable<? extends R>> fn)
```
 Description copied from interface: ReactiveSeq
 FlatMap where the result is a Collection, flattens the resultant collections into the host ReactiveSeq
```
 
 	ReactiveSeq.of(1,2)
 			.flatMap(i -> asList(i, -i))
 .toList();
 
 //1,-1,2,-2 
 
 
```
 Specified by:
 
 flatMapIterable in interface ReactiveSeq
 
 Returns:
 - flatMapStream
```
default <R> LazyFutureStream<R> flatMapStream(java.util.function.Function<? super U,java.util.stream.BaseStream<? extends R,?>> fn)
```
 Description copied from interface: ReactiveSeq
 flatMap operation
```
 
 	assertThat(ReactiveSeq.of(1,2,3)
 .flatMapStream(i->IntStream.of(i))
 .toList(),equalTo(Arrays.asList(1,2,3)));
 
 
 
```
 Specified by:
 
 flatMapStream in interface ReactiveSeq
 
 Parameters:
 
 fn - to be applied
 
 Returns:
 
 new stage in Sequence with flatMap operation to be lazily applied
 - toLazyCollection
```
default CollectionX toLazyCollection()
```
 Description copied from interface: ReactiveSeq
 Lazily converts this ReactiveSeq into a Collection. This does not trigger the Stream. E.g. Collection is not thread safe on the first iteration.
```
 {
 @code
 Collection<Integer> col = ReactiveSeq.of(1, 2, 3, 4, 5).peek(System.out::println).toLazyCollection();
 
 col.forEach(System.out::println);
 }
 
 // Will print out "first!" before anything else
 
```
 Specified by:
 
 toLazyCollection in interface Foldable
 
 Specified by:
 
 toLazyCollection in interface ReactiveSeq
 
 Returns:
 - toConcurrentLazyCollection
```
default CollectionX toConcurrentLazyCollection()
```
 Description copied from interface: ReactiveSeq
 Lazily converts this ReactiveSeq into a Collection. This does not trigger the Stream. E.g.
```
 {
 @code
 Collection<Integer> col = ReactiveSeq.of(1, 2, 3, 4, 5).peek(System.out::println).toConcurrentLazyCollection();
 
 col.forEach(System.out::println);
 }
 
 // Will print out "first!" before anything else
 
```
 Specified by:
 
 toConcurrentLazyCollection in interface Foldable
 
 Specified by:
 
 toConcurrentLazyCollection in interface ReactiveSeq
 
 Returns:
 - toConcurrentLazyStreamable
```
default Streamable toConcurrentLazyStreamable()
```
 Description copied from interface: ReactiveSeq
```
 {
 @code
 Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6).map(i -> i + 2).toConcurrentLazyStreamable();
 
 assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));
 assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));
 }
 
```
 Specified by:
 
 toConcurrentLazyStreamable in interface Foldable
 
 Specified by:
 
 toConcurrentLazyStreamable in interface ReactiveSeq
 
 Returns:
 
 Streamable that replay this ReactiveSeq, populated lazily and can be populated across threads
 - appendStream
```
default LazyFutureStream appendStream(java.util.stream.Stream stream)
```
 Description copied from interface: ReactiveSeq
 Append Stream to this ReactiveSeq
```
 {
 @code
 List<String> result = ReactiveSeq.of(1, 2, 3).appendStream(ReactiveSeq.of(100, 200, 300)).map(it -> it + "!!").collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!")));
 }
 
```
 Specified by:
 
 appendStream in interface ReactiveSeq
 
 Parameters:
 
 stream - to append
 
 Returns:
 
 ReactiveSeq with Stream appended
 - prependStream
```
default LazyFutureStream prependStream(java.util.stream.Stream stream)
```
 Description copied from interface: ReactiveSeq
 Prepend Stream to this ReactiveSeq
```
 {
 @code
 List<String> result = ReactiveSeq.of(1, 2, 3).prependStream(of(100, 200, 300)).map(it -> it + "!!").collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
 
 }
 
```
 Specified by:
 
 prependStream in interface ReactiveSeq
 
 Parameters:
 
 stream - to Prepend
 
 Returns:
 
 ReactiveSeq with Stream prepended
 - append
```
default LazyFutureStream append(U... values)
```
 Description copied from interface: ReactiveSeq
 Append values to the end of this ReactiveSeq
```
 {
 @code
 List<String> result = ReactiveSeq.of(1, 2, 3).append(100, 200, 300).map(it -> it + "!!").collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!")));
 }
 
```
 Specified by:
 
 append in interface ReactiveSeq
 
 Specified by:
 
 append in interface org.jooq.lambda.Seq
 
 Parameters:
 
 values - to append
 
 Returns:
 
 ReactiveSeq with appended values
 - prepend
```
default LazyFutureStream prepend(U... values)
```
 Description copied from interface: ReactiveSeq
 Prepend given values to the start of the Stream
```
 
 List<String> result = 	ReactiveSeq.of(1,2,3)
 									 .prepend(100,200,300)
 										 .map(it ->it+"!!")
 										 .collect(Collectors.toList());
 
 			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 
```
 Specified by:
 
 prepend in interface ReactiveSeq
 
 Specified by:
 
 prepend in interface org.jooq.lambda.Seq
 
 Parameters:
 
 values - to prepend
 
 Returns:
 
 ReactiveSeq with values prepended
 - insertAt
```
default LazyFutureStream insertAt(int pos,
 U... values)
```
 Description copied from interface: ReactiveSeq
 Insert data into a stream at given position
```
 {
 @code
 List<String> result = ReactiveSeq.of(1, 2, 3).insertAt(1, 100, 200, 300).map(it -> it + "!!").collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
 
 }
 
```
 Specified by:
 
 insertAt in interface ReactiveSeq
 
 Parameters:
 
 pos - to insert data at
 
 values - to insert
 
 Returns:
 
 Stream with new data inserted
 - deleteBetween
```
default LazyFutureStream deleteBetween(int start,
 int end)
```
 Description copied from interface: ReactiveSeq
 Delete elements between given indexes in a Stream
```
 {
 @code
 List<String> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).deleteBetween(2, 4).map(it -> it + "!!").collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "5!!", "6!!")));
 }
 
```
 Specified by:
 
 deleteBetween in interface ReactiveSeq
 
 Parameters:
 
 start - index
 
 end - index
 
 Returns:
 
 Stream with elements removed
 - insertStreamAt
```
default LazyFutureStream insertStreamAt(int pos,
 java.util.stream.Stream stream)
```
 Description copied from interface: ReactiveSeq
 Insert a Stream into the middle of this stream at the specified position
```
 {
 @code
 List<String> result = ReactiveSeq.of(1, 2, 3).insertStreamAt(1, of(100, 200, 300)).map(it -> it + "!!").collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
 }
 
```
 Specified by:
 
 insertStreamAt in interface ReactiveSeq
 
 Parameters:
 
 pos - to insert Stream at
 
 stream - to insert
 
 Returns:
 
 newly conjoined ReactiveSeq
 - futureOperations
```
default FutureOperations futureOperations()
```
 Returns:
 
 access to asynchronous terminal operations
 - futureOperations
```
default FutureOperations futureOperations(java.util.concurrent.Executor exec)
```
 Description copied from interface: ReactiveSeq
 
 Access asynchronous terminal operations (each returns a Future)
 
 Specified by:
 
 futureOperations in interface ReactiveSeq
 
 Specified by:
 
 futureOperations in interface Traversable
 
 Parameters:
 
 exec - Executor to use for Stream execution
 
 Returns:
 
 Async Future Terminal Operations
 - skip
```
default LazyFutureStream skip(long time,
 java.util.concurrent.TimeUnit unit)
```
 Description copied from interface: ReactiveSeq
 Skip all elements until specified time period has passed
```
 {
 @code
 List<Integer> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).peek(i -> sleep(i * 100)).skip(1000, TimeUnit.MILLISECONDS).toList();
 
 // [4,5,6]
 
 }
 
```
 Specified by:
 
 skip in interface ReactiveSeq
 
 Parameters:
 
 time - Length of time
 
 unit - Time unit
 
 Returns:
 
 ReactiveSeq that skips all elements until time period has elapsed
 - limit
```
default LazyFutureStream limit(long time,
 java.util.concurrent.TimeUnit unit)
```
 Description copied from interface: ReactiveSeq
 Return all elements until specified time period has elapsed
```
 {
 @code
 List<Integer> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).peek(i -> sleep(i * 100)).limit(1000, TimeUnit.MILLISECONDS).toList();
 
 // [1,2,3,4]
 }
 
```
 Specified by:
 
 limit in interface ReactiveSeq
 
 Parameters:
 
 time - Length of time
 
 unit - Time unit
 
 Returns:
 
 ReactiveSeq that returns all elements until time period has elapsed
 - skipLast
```
default LazyFutureStream skipLast(int num)
```
 Description copied from interface: ReactiveSeq
 
 assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
 
 Specified by:
 
 skipLast in interface ReactiveSeq
 
 Specified by:
 
 skipLast in interface Traversable
 
 Returns:
 - limitLast
```
default LazyFutureStream limitLast(int num)
```
 Description copied from interface: ReactiveSeq
 Limit results to the last x elements in a ReactiveSeq
```
 
 	assertThat(ReactiveSeq.of(1,2,3,4,5)
 							.limitLast(2)
 							.collect(Collectors.toList()),equalTo(Arrays.asList(4,5)));
 
 
```
 Specified by:
 
 limitLast in interface ReactiveSeq
 
 Specified by:
 
 limitLast in interface Traversable
 
 Parameters:
 
 num - of elements to return (last elements)
 
 Returns:
 
 ReactiveSeq limited to last num elements
 - firstValue
```
default U firstValue()
```
 Description copied from interface: ReactiveSeq
```
 
 	assertThat(ReactiveSeq.of(1,2,3,4)
 					.map(u->{throw new RuntimeException();})
 					.recover(e->"hello")
 					.firstValue(),equalTo("hello"));
 
 
```
 Specified by:
 
 firstValue in interface Foldable
 
 Specified by:
 
 firstValue in interface ReactiveSeq
 
 Returns:
 
 first value in this Stream
 - groupedBySizeAndTime
```
default <C extends java.util.Collection<? super U>> LazyFutureStream<C> groupedBySizeAndTime(int size,
 long time,
 java.util.concurrent.TimeUnit unit,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: ReactiveSeq
 Batch elements by size into a collection created by the supplied factory
```
 {
 @code
 List<ArrayList<Integer>> list = of(1, 2, 3, 4, 5, 6).batchBySizeAndTime(10, 1, TimeUnit.MICROSECONDS, () -> new ArrayList<>()).toList();
 }
 
```
 Specified by:
 
 groupedBySizeAndTime in interface ReactiveSeq
 
 Parameters:
 
 size - Max size of a batch
 
 time - (Max) time period to build a single batch in
 
 unit - time unit for batch
 
 factory - Collection factory
 
 Returns:
 
 ReactiveSeq batched by size and time
 - groupedStatefullyWhile
```
default LazyFutureStream<ListX> groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super U>,? super U> predicate)
```
 Description copied from interface: ReactiveSeq
 Create ReactiveSeq of ListX where each ListX is populated while the supplied bipredicate holds. The bipredicate recieves the ListX from the last window as well as the current value and can choose to aggregate the current value or create a new window
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedStatefullyWhile((s,i)-> s.contains(4) ? true : false)
 .toList().size(),equalTo(5));
 
 
```
 Specified by:
 
 groupedStatefullyWhile in interface ReactiveSeq
 
 Specified by:
 
 groupedStatefullyWhile in interface Traversable
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 ReactiveSeq windowed while predicate holds
 - groupedUntil
```
default LazyFutureStream<ListX> groupedUntil(java.util.function.Predicate<? super U> predicate)
```
 Description copied from interface: ReactiveSeq
 Create a ReactiveSeq batched by List, where each batch is populated until the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .batchUntil(i->i%3==0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedUntil in interface ReactiveSeq
 
 Specified by:
 
 groupedUntil in interface Traversable
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 Returns:
 
 ReactiveSeq batched into lists determined by the predicate supplied
 - groupedWhile
```
default LazyFutureStream<ListX> groupedWhile(java.util.function.Predicate<? super U> predicate)
```
 Description copied from interface: ReactiveSeq
 Create a ReactiveSeq batched by List, where each batch is populated while the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .batchWhile(i->i%3!=0)
 .toList().size(),equalTo(2));
 
 
 
```
 Specified by:
 
 groupedWhile in interface ReactiveSeq
 
 Specified by:
 
 groupedWhile in interface Traversable
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 Returns:
 
 ReactiveSeq batched into lists determined by the predicate supplied
 - groupedWhile
```
default <C extends java.util.Collection<? super U>> LazyFutureStream<C> groupedWhile(java.util.function.Predicate<? super U> predicate,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: ReactiveSeq
 Create a ReactiveSeq batched by a Collection, where each batch is populated while the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .batchWhile(i->i%3!=0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedWhile in interface ReactiveSeq
 
 Specified by:
 
 groupedWhile in interface Traversable
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 ReactiveSeq batched into collections determined by the predicate supplied
 - 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 ReactiveSeq
 
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq
 
 Specified by:
 
 sorted in interface Traversable
 - groupedUntil
```
default <C extends java.util.Collection<? super U>> LazyFutureStream<C> groupedUntil(java.util.function.Predicate<? super U> predicate,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: ReactiveSeq
 Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .batchUntil(i->i%3!=0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedUntil in interface ReactiveSeq
 
 Specified by:
 
 groupedUntil in interface Traversable
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 ReactiveSeq batched into collections determined by the predicate supplied
 - recover
```
default LazyFutureStream recover(java.util.function.Function<java.lang.Throwable,? extends U> fn)
```
 Description copied from interface: ReactiveSeq
 Recover from an exception with an alternative value
```
 
 assertThat(ReactiveSeq.of(1,2,3,4)
 						 .map(i->i+2)
 						 .map(u->{throw new RuntimeException();})
 						 .recover(e->"hello")
 						 .firstValue(),equalTo("hello"));
 
 
```
 Specified by:
 
 recover in interface ReactiveSeq
 
 Parameters:
 
 fn - Function that accepts a Throwable and returns an alternative value
 
 Returns:
 
 ReactiveSeq that can recover from an Exception
 - recover
```
default <EX extends java.lang.Throwable> LazyFutureStream recover(java.lang.Class<EX> exceptionClass,
 java.util.function.Function<EX,? extends U> fn)
```
 Description copied from interface: ReactiveSeq
 Recover from a particular exception type
```
 
 assertThat(ReactiveSeq.of(1,2,3,4)
 					.map(i->i+2)
 					.map(u->{ExceptionSoftener.throwSoftenedException( new IOException()); return null;})
 					.recover(IOException.class,e->"hello")
 					.firstValue(),equalTo("hello"));
 
 
 
```
 Specified by:
 
 recover in interface ReactiveSeq
 
 Parameters:
 
 exceptionClass - Type to recover from
 
 fn - That accepts an error and returns an alternative value
 
 Returns:
 
 Sequence that can recover from a particular exception
 - forEachX
```
default <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachX(long numberOfElements,
 java.util.function.Consumer<? super U> consumer)
```
 Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription e.g.
 Specified by:
 
 forEachX in interface ReactiveStreamsTerminalOperations
 
 Parameters:
 
 numberOfElements - To consume from the Stream at this time
 
 consumer - To accept incoming events from the Stream
 
 Returns:
 
 Subscription so that further processing can be continued or cancelled.
 - forEachXWithError
```
default <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachXWithError(long numberOfElements,
 java.util.function.Consumer<? super U> consumer,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError)
```
 Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription
 Specified by:
 
 forEachXWithError in interface ReactiveStreamsTerminalOperations
 
 Parameters:
 
 numberOfElements - To consume from the Stream at this time
 
 consumer - To accept incoming elements from the Stream
 
 consumerError - To accept incoming processing errors from the Stream
 
 onComplete - To run after an onComplete event
 
 Returns:
 
 Subscription so that further processing can be continued or cancelled.
 - forEachXEvents
```
default <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachXEvents(long numberOfElements,
 java.util.function.Consumer<? super U> consumer,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError,
 java.lang.Runnable onComplete)
```
 Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription, when the entire Stream has been processed an onComplete event will be recieved.
 Specified by:
 
 forEachXEvents in interface ReactiveStreamsTerminalOperations
 
 Parameters:
 
 numberOfElements - To consume from the Stream at this time
 
 consumer - To accept incoming elements from the Stream
 
 consumerError - To accept incoming processing errors from the Stream
 
 onComplete - To run after an onComplete event
 
 Returns:
 
 Subscription so that further processing can be continued or cancelled.
 - forEachWithError
```
default <X extends java.lang.Throwable> void forEachWithError(java.util.function.Consumer<? super U> consumerElement,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError)
```
 Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,
 Specified by:
 
 forEachWithError in interface ReactiveStreamsTerminalOperations
 
 Parameters:
 
 consumer - To accept incoming elements from the Stream
 
 consumerError - To accept incoming processing errors from the Stream
 - forEachEvent
```
default <X extends java.lang.Throwable> void forEachEvent(java.util.function.Consumer<? super U> consumerElement,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError,
 java.lang.Runnable onComplete)
```
 Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers when the entire Stream has been processed an onComplete event will be recieved.
 Specified by:
 
 forEachEvent in interface ReactiveStreamsTerminalOperations
 
 Parameters:
 
 consumer - To accept incoming elements from the Stream
 
 consumerError - To accept incoming processing errors from the Stream
 
 onComplete - To run after an onComplete event
 - 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 ReactiveSeq
 
 Specified by:
 
 of in interface org.jooq.lambda.Seq
 
 Specified by:
 
 of in interface java.util.stream.Stream
 
 Parameters:
 
 value - To Construct sequence from
 - 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 ReactiveSeq
 
 Specified by:
 
 of in interface org.jooq.lambda.Seq
 
 Specified by:
 
 of in interface java.util.stream.Stream
 
 Parameters:
 
 values - To Construct sequence from
 - 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 ReactiveSeq
 
 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 ReactiveSeq
 
 Specified by:
 
 iterate in interface org.jooq.lambda.Seq
 
 Specified by:
 
 iterate in interface java.util.stream.Stream
 
 See Also:
 
 Stream.iterate(Object, UnaryOperator)
 - generate
```
static LazyFutureStream<java.lang.Void> generate()
```
 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 ReactiveSeq
 
 Specified by:
 
 generate in interface org.jooq.lambda.Seq
 
 Specified by:
 
 generate in interface java.util.stream.Stream
 
 See Also:
 
 Stream.generate(Supplier)
 - generate
```
static <T> LazyFutureStream<T> generate(java.util.function.Supplier<T> s)
```
 Generate an infinite Stream of value returned from Supplier that runs on the current thread
 
 Specified by:
 
 generate in interface ReactiveSeq
 
 Specified by:
 
 generate in interface org.jooq.lambda.Seq
 
 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.cyclops.types.futurestream.LazySimpleReactStream

Methods inherited from interface com.aol.cyclops.types.futurestream.ConfigurableStream

Methods inherited from interface com.aol.cyclops.types.futurestream.BaseSimpleReactStream

Methods inherited from interface com.aol.cyclops.types.futurestream.BlockingStream

Methods inherited from interface com.aol.cyclops.types.futurestream.LazyStream

Methods inherited from interface com.aol.cyclops.control.ReactiveSeq

Methods inherited from interface com.aol.cyclops.types.stream.JoolManipulation

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

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

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable

Methods inherited from interface com.aol.cyclops.types.stream.JoolWindowing

Methods inherited from interface org.jooq.lambda.Seq

Methods inherited from interface java.util.stream.Stream

Methods inherited from interface com.aol.cyclops.types.applicative.zipping.ZippingApplicativable

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

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

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

Methods inherited from interface com.aol.cyclops.types.stream.ConvertableSequence

Methods inherited from interface com.aol.cyclops.types.futurestream.LazyToQueue

Methods inherited from interface com.aol.cyclops.types.futurestream.ToQueue

Methods inherited from interface com.aol.cyclops.types.stream.reactive.FutureStreamSynchronousPublisher

Method Detail

filterNot

notNull

trampoline

foldRight

applicatives

ap1

elapsed

combine

onEmptySwitch

forEach3

forEach3

forEach2

forEach2

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

reduce

collect

sync

async

unboundedWaitFree

boundedWaitFree

maxActive

thenSync

peekSync

closeAll

hotStream

findFirst

convertToSimpleReact

map

shard

debounce