LazyFutureStream (cyclops-react 1.0.2 API)

All Superinterfaces:

java.lang.AutoCloseable, BaseSimpleReactStream, java.util.stream.BaseStream<U,java.util.stream.Stream>, BlockingStream, org.jooq.lambda.Collectable, ConfigurableStream<U,com.aol.cyclops.internal.react.async.future.FastFuture>, ConvertableSequence, CyclopsCollectable, ExtendedTraversable, Filterable, FilterableFunctor, Foldable, Functor, FutureStreamSynchronousPublisher, java.lang.Iterable, IterableFilterable, IterableFoldable, IterableFunctor, JoolManipulation, JoolWindowing, LazySimpleReactStream, LazyStream, LazyToQueue, OnEmpty, OnEmptySwitch<U,java.util.stream.Stream>, org.reactivestreams.Publisher, ReactiveSeq, ReactiveStreamsTerminalOperations, org.jooq.lambda.Seq, java.util.stream.Stream, To<ReactiveSeq>, ToQueue, TransformerTraversable, Traversable, Unit, Unwrapable, Zippable, ZippingApplicativable
```
public interface LazyFutureStream
extends Functor, Filterable, LazySimpleReactStream, LazyStream, ReactiveSeq, LazyToQueue, ConfigurableStream<U,com.aol.cyclops.internal.react.async.future.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 and 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()` Count the values in this collectable.
`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)` Get a stream of distinct keys.
`default LazyFutureStream<U>`	`drop(long drop)` Alias for skip
`default LazyFutureStream<U>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the end of this Traversable
`default LazyFutureStream<U>`	`dropUntil(java.util.function.Predicate<? super U> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`default LazyFutureStream<U>`	`dropWhile(java.util.function.Predicate<? super U> p)` Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
`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)` Fold a Stream to the right.
`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<com.aol.cyclops.internal.react.async.future.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>>`	`groupedStatefullyUntil(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 com.aol.cyclops.internal.react.stream.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()` Seq streams are always sequential and, as such, doesn't support parallelization.
`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)` An equivalent function to `Stream.reduce(BinaryOperator)`
`default <T> T`	`reduce(T identity, java.util.function.BiFunction<T,? super U,T> accumulator)` An equivalent function to `Stream.reduce(Object, BinaryOperator)`
`default <T> T`	`reduce(T identity, java.util.function.BiFunction<T,? super U,T> accumulator, java.util.function.BinaryOperator<T> combiner)` An equivalent function to `Stream.reduce(Object, BiFunction, BinaryOperator)`
`default U`	`reduce(U identity, java.util.function.BinaryOperator<U> accumulator)` An equivalent function to `Stream.reduce(Object, BinaryOperator)`
`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()` Returns this stream.
`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)` Returns a limited interval from a given Stream.
`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)` Sort by the results of 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>`	`take(long take)` Alias for limit
`default LazyFutureStream<U>`	`takeRight(int num)` Generate a new Traversable that takes the specified number elements from the end of this Traversable
`default LazyFutureStream<U>`	`takeUntil(java.util.function.Predicate<? super U> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`default LazyFutureStream<U>`	`takeWhile(java.util.function.Predicate<? super U> p)` Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
`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)` Collect the collectable into a `Collection`.
`default java.util.concurrent.CompletableFuture<ListX<U>>`	`toCompletableFuture()`
`default CollectionX<U>`	`toConcurrentLazyCollection()` Lazily converts this ReactiveSeq into a Collection.
`default Streamable<U>`	`toConcurrentLazyStreamable()` `Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6).map(i -> i + 2).toConcurrentLazyStreamable(); assertThat(repeat.stream().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12))); assertThat(repeat.stream().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()` Collect the collectable into an `ArrayList`.
`default java.util.Optional<ListX<U>>`	`toOptional()`
`default Queue<U>`	`toQueue()` Convert the current Stream to a simple-react Queue
`default java.util.Set<U>`	`toSet()` Collect the collectable into a `LinkedHashSet`.
`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.stream().toList(); //Arrays.asList(2,4,6,8,10,12)); repeat.stream().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()` Returns this stream.
`default <R> R`	`unwrap()` START SEQUENCEM
`LazyFutureStream<U>`	`withAsync(boolean async)`
`<R> LazyFutureStream<R>`	`withLastActive(com.aol.cyclops.internal.react.stream.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 <T2,R> LazyFutureStream<R>`	`zip(java.util.function.BiFunction<? super U,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> publisher)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`zip(java.lang.Iterable<? extends T> other)` Zip two streams into one.
`default <T,R> LazyFutureStream<R>`	`zip(java.lang.Iterable<? 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(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)` Zip two streams into one using a `BiFunction` to produce resulting values.
`default <S,R> LazyFutureStream<org.jooq.lambda.tuple.Tuple3<U,S,R>>`	`zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends R> third)` 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 Stream with another
`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.To
to

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
groupedStatefullyUntilT, 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, 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, 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
 
 Parameters:
 
 mapper - TCO Transformation function
 
 Returns:
 
 Functor transformed by the supplied transformation function
 - foldRight
```
default <R> R foldRight(R identity,
 java.util.function.BiFunction<? super U,? super R,? extends R> accumulator)
```
 Description copied from interface: org.jooq.lambda.Seq
 Fold a Stream to the right.
```
 // "abc!"
 Seq.of("a", "b", "c").foldRight("!", (t, u) -> t + u)
 
```
 Specified by:
 
 foldRight in interface Foldable
 
 Specified by:
 
 foldRight in interface ReactiveSeq
 
 Specified by:
 
 foldRight in interface org.jooq.lambda.Seq
 
 Parameters:
 
 identity - Identity value for the combiner function (leaves the input unchanged)
 
 accumulator - Combining function
 
 Returns:
 
 Reduced value
 - 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
 - zip
```
default <T2,R> LazyFutureStream<R> zip(java.util.function.BiFunction<? super U,? super T2,? extends R> fn,
 org.reactivestreams.Publisher<? extends T2> publisher)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
 
 Specified by:
 
 zip in interface Zippable
 
 Parameters:
 
 fn - Zip / combining function
 
 publisher - to combine with
 
 Returns:
 
 Combined zippable
 - 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 and 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 OnEmptySwitch<U,java.util.stream.Stream>
 
 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 com.aol.cyclops.internal.react.stream.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(com.aol.cyclops.internal.react.stream.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,com.aol.cyclops.internal.react.async.future.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()
```
 Description copied from interface: org.jooq.lambda.Collectable
 
 Count the values in this collectable.
 
 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,com.aol.cyclops.internal.react.async.future.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,com.aol.cyclops.internal.react.async.future.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,com.aol.cyclops.internal.react.async.future.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,com.aol.cyclops.internal.react.async.future.FastFuture>
 
 Specified by:
 
 withSubscription in interface LazySimpleReactStream
 - withAsync
```
LazyFutureStream withAsync(boolean async)
```
 Specified by:
 
 withAsync in interface ConfigurableStream<U,com.aol.cyclops.internal.react.async.future.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)
```
 Description copied from interface: Foldable
 
 An equivalent function to Stream.reduce(Object, BinaryOperator)
 
 Specified by:
 
 reduce in interface Foldable
 
 Specified by:
 
 reduce in interface LazyStream
 
 Parameters:
 
 identity - Identity value for the combiner function (leaves the input unchanged)
 
 accumulator - Combiner function
 
 Returns:
 
 Value produced by applying the current accumulated value and the next value to the combiner function as this Foldable is traversed from left to right
 - reduce
```
default U reduce(U identity,
 java.util.function.BinaryOperator accumulator)
```
 Description copied from interface: Foldable
 
 An equivalent function to Stream.reduce(Object, BinaryOperator)
 
 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
 
 accumulator - Combiner function
 
 Returns:
 
 Value produced by applying the current accumulated value and the next value to the combiner function as this Foldable is traversed from left to right
 - reduce
```
default <T> T reduce(T identity,
 java.util.function.BiFunction<T,? super U,T> accumulator,
 java.util.function.BinaryOperator<T> combiner)
```
 Description copied from interface: Foldable
 
 An equivalent function to Stream.reduce(Object, BiFunction, BinaryOperator)
 
 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)
```
 Description copied from interface: Foldable
 An equivalent function to Stream.reduce(BinaryOperator)
```
 
 
 ReactiveSeq.of(1,2,3,4,5).map(it -> it*100).reduce(
 (acc,next) -> acc+next)
 //Optional[1500]
 
 
```
 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
 
 Parameters:
 
 accumulator - Combiner function
 
 Returns:
 - 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)
 .groupedBySizeAndTime(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<com.aol.cyclops.internal.react.async.future.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
 
 See Also:
 
 Seq.cast(Stream, Class)
 - 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
 
 See Also:
 
 Seq.ofType(Stream, Class)
 - intersperse
```
default LazyFutureStream intersperse(U value)
```
 Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) LazyFutureStream.of(1, 2, 3, 4).intersperse(0)
 
 Specified by:
 
 intersperse in interface 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
 - drop
```
default LazyFutureStream drop(long drop)
```
 Description copied from interface: org.jooq.lambda.Seq
 
 Alias for skip
 
 Specified by:
 
 drop in interface ReactiveSeq
 
 Specified by:
 
 drop in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.skip(long)
 - take
```
default LazyFutureStream take(long take)
```
 Description copied from interface: org.jooq.lambda.Seq
 
 Alias for limit
 
 Specified by:
 
 take in interface ReactiveSeq
 
 Specified by:
 
 take in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.limit(long)
 - takeWhile
```
default LazyFutureStream takeWhile(java.util.function.Predicate<? super U> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
```
 
 ListX.of(1,2,3).takeWhile(i<3);
 //[1,2]
 
 
```
 Specified by:
 
 takeWhile in interface ReactiveSeq
 
 Specified by:
 
 takeWhile in interface Traversable
 
 Parameters:
 
 p - Predicate to determine when values should be taken
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropWhile
```
default LazyFutureStream dropWhile(java.util.function.Predicate<? super U> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
```
 
 ListX.of(1,2,3).dropWhile(i<3);
 //[3]
 
 
```
 Specified by:
 
 dropWhile in interface ReactiveSeq
 
 Specified by:
 
 dropWhile in interface Traversable
 
 Parameters:
 
 p - Predicate to determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - takeUntil
```
default LazyFutureStream takeUntil(java.util.function.Predicate<? super U> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes elements from this Traversable until the predicate holds
```
 
 ListX.of(1,2,3).takeUntil(i<2);
 //[1,2]
 
 
```
 Specified by:
 
 takeUntil in interface ReactiveSeq
 
 Specified by:
 
 takeUntil in interface Traversable
 
 Parameters:
 
 p - Predicate to determine when values should be taken until
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropUntil
```
default LazyFutureStream dropUntil(java.util.function.Predicate<? super U> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops elements from this Traversable until the predicate holds
```
 
 ListX.of(1,2,3).dropUntil(i>2);
 //[3]
 
 
```
 Specified by:
 
 dropUntil in interface ReactiveSeq
 
 Specified by:
 
 dropUntil in interface Traversable
 
 Parameters:
 
 p - Predicate to determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropRight
```
default LazyFutureStream dropRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops the specified number elements from the end of this Traversable
```
 
 ListX.of(1,2,3).dropRight(2);
 //[1]
 
 
```
 Specified by:
 
 dropRight in interface ReactiveSeq
 
 Specified by:
 
 dropRight in interface Traversable
 
 Parameters:
 
 num - Drop this number of elements from the end of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - takeRight
```
default LazyFutureStream takeRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes the specified number elements from the end of this Traversable
```
 
 ListX.of(1,2,3).takeRight(2);
 //[2,3]
 
 
```
 Specified by:
 
 takeRight in interface ReactiveSeq
 
 Specified by:
 
 takeRight in interface Traversable
 
 Parameters:
 
 num - Take this number of elements from the end of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - 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)
```
 Description copied from interface: org.jooq.lambda.Seq
 Returns a limited interval from a given Stream.
```
 // (4, 5)
 Seq.of(1, 2, 3, 4, 5, 6).slice(3, 5)
 
```
 Specified by:
 
 slice in interface ReactiveSeq
 
 Specified by:
 
 slice in interface org.jooq.lambda.Seq
 
 Specified by:
 
 slice in interface Traversable
 
 See Also:
 
 Seq.slice(Stream, long, long)
 - zipWithIndex
```
default LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,java.lang.Long>> zipWithIndex()
```
 Zip a Stream with a corresponding Stream of indexes. // (tuple("a", 0), tuple("b", 1), tuple("c", 2)) LazyFutureStream.of("a","b", "c").zipWithIndex()
 
 Specified by:
 
 zipWithIndex in interface 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
 
 Specified by:
 
 zip in interface Zippable
 
 Parameters:
 
 other - Seq to combine with
 
 Returns:
 
 Combined Zippable
 
 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
```
 
 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
 
 Specified by:
 
 zip in interface Zippable
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 
 See Also:
 
 Seq.zip(Stream, Stream)
 - zip
```
default <T> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> zip(java.lang.Iterable<? extends T> other)
```
 Description copied from interface: org.jooq.lambda.Seq
 Zip two streams into one.
```
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 
```
 Specified by:
 
 zip in interface ReactiveSeq
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 zip in interface Traversable
 
 Specified by:
 
 zip in interface Zippable
 
 Parameters:
 
 other - Iterable to combine with
 
 Returns:
 
 See Also:
 
 Seq.zip(Stream, Stream)
 - 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
 
 Specified by:
 
 zip in interface Zippable
 
 Parameters:
 
 other - Seq to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 
 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)
```
 Description copied from interface: org.jooq.lambda.Seq
 Zip two streams into one using a BiFunction to produce resulting values.
```
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 
```
 Specified by:
 
 zip in interface ReactiveSeq
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 zip in interface Traversable
 
 Specified by:
 
 zip in interface Zippable
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 
 See Also:
 
 Seq.zip(Seq, BiFunction)
 - zip
```
default <T,R> LazyFutureStream<R> zip(java.lang.Iterable<? extends T> other,
 java.util.function.BiFunction<? super U,? super T,? extends R> zipper)
```
 Description copied from interface: org.jooq.lambda.Seq
 Zip two streams into one using a BiFunction to produce resulting values.
```
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 
```
 Specified by:
 
 zip in interface ReactiveSeq
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq
 
 Specified by:
 
 zip in interface Traversable
 
 Specified by:
 
 zip in interface Zippable
 
 Parameters:
 
 other - to zip with
 
 zipper - Zip function
 
 Returns:
 
 Combined zippable
 
 See Also:
 
 Seq.zip(Seq, BiFunction)
 - 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 OnEmpty
 
 Specified by:
 
 onEmpty in interface ReactiveSeq
 
 Specified by:
 
 onEmpty in interface org.jooq.lambda.Seq
 
 Specified by:
 
 onEmpty in interface Traversable
 
 Returns:
 
 New instance containing value if container is empty, otherwise returns this container
 - 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 OnEmpty
 
 Specified by:
 
 onEmptyGet in interface ReactiveSeq
 
 Specified by:
 
 onEmptyGet in interface org.jooq.lambda.Seq
 
 Specified by:
 
 onEmptyGet in interface Traversable
 
 Parameters:
 
 supplier - to determine new value for container
 
 Returns:
 
 New Container with value if this is empty, otherwise this container
 - 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 OnEmpty
 
 Specified by:
 
 onEmptyThrow in interface ReactiveSeq
 
 Specified by:
 
 onEmptyThrow in interface org.jooq.lambda.Seq
 
 Specified by:
 
 onEmptyThrow in interface Traversable
 
 Parameters:
 
 supplier - to create exception from
 
 Returns:
 
 Throw exception if empty, otherwise this container
 - 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
 
 See Also:
 
 Seq.cycle(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
 
 Returns:
 
 This Foldable as a ReactiveSeq with it's type narrowed to a Foldable
 - 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
 
 Returns:
 
 This Traversable converted to a Stream
 - parallel
```
default LazyFutureStream parallel()
```
 Description copied from interface: org.jooq.lambda.Seq
 
 Seq streams are always sequential and, as such, doesn't support parallelization.
 
 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
 
 See Also:
 
 jOOL Issue #130
 - sequential
```
default LazyFutureStream sequential()
```
 Description copied from interface: org.jooq.lambda.Seq
 
 Returns this stream. All Seq streams are sequential, hence the name.
 
 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
 
 Returns:
 
 this stream unmodified
 - unordered
```
default LazyFutureStream unordered()
```
 Description copied from interface: org.jooq.lambda.Seq
 
 Returns this stream. All Seq streams are ordered so this method has no effect.
 
 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
 
 Returns:
 
 this stream unmodified
 - 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()
```
 Specified by:
 
 toOptional in interface ConvertableSequence
 - toCompletableFuture
```
default java.util.concurrent.CompletableFuture<ListX> toCompletableFuture()
```
 Specified by:
 
 toCompletableFuture in interface ConvertableSequence
 - 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()
```
 Description copied from interface: org.jooq.lambda.Collectable
 
 Collect the collectable into a LinkedHashSet.
 
 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()
```
 Description copied from interface: org.jooq.lambda.Collectable
 
 Collect the collectable into an ArrayList.
 
 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)
```
 Description copied from interface: org.jooq.lambda.Collectable
 
 Collect the collectable into a Collection.
 
 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)
```
 Description copied from interface: org.jooq.lambda.Seq
 Get a stream of distinct keys.
```
 // (1, 2, 3)
 Seq.of(1, 1, 2, -2, 3).distinct(Math::abs)
 
```
 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.
```
 
 
 	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.
```
 
 	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.
```
 
 	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:
 
 Tuple4 containing 4 duplicated ReactiveSeqs
 - 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
```
 
 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
```
 
 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 Stream with another
```
 
 Stream<List<Integer>> zipped = ReactiveSeq.of(1, 2, 3)).zipStream(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
```
 
 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:
 
 ReactiveSeq with values combined scanning left
 - 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.stream().toList(); //Arrays.asList(2,4,6,8,10,12));
 		repeat.stream().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
 
 Parameters:
 
 iterator - Stream to check if this Foldable has the same elements in the same order, at the start
 
 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.
```
 
 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:
 
 Lazy Collection
 - toConcurrentLazyCollection
```
default CollectionX toConcurrentLazyCollection()
```
 Description copied from interface: ReactiveSeq
 Lazily converts this ReactiveSeq into a Collection. This does not trigger the Stream. E.g.
```
 
 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:
 
 Concurrent Lazy Collection
 - toConcurrentLazyStreamable
```
default Streamable toConcurrentLazyStreamable()
```
 Description copied from interface: ReactiveSeq
```
 
 Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6).map(i -> i + 2).toConcurrentLazyStreamable();
 
 assertThat(repeat.stream().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));
 assertThat(repeat.stream().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
```
 
 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
```
 
 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
```
 
 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
 
 See Also:
 
 Seq.concat(Stream[])
 - 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
 
 See Also:
 
 Seq.concat(Stream[])
 - insertAt
```
default LazyFutureStream insertAt(int pos,
 U... values)
```
 Description copied from interface: ReactiveSeq
 Insert data into a stream at given position
```
 
 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
```
 
 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
```
 
 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
```
 
 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
```
 
 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
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .groupedBySizeAndTime(3,10,TimeUnit.SECONDS,()->SetX.empty())
 .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
 
 factory - Collection factory
 
 Returns:
 
 ReactiveSeq batched by size and time
 - groupedStatefullyUntil
```
default LazyFutureStream<ListX> groupedStatefullyUntil(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
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .groupedStatefullyUntil((s,i)-> s.contains(4) ? true : false)
 .toList()
 .size()
 //5
 
 
```
 Specified by:
 
 groupedStatefullyUntil in interface ReactiveSeq
 
 Specified by:
 
 groupedStatefullyUntil 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)
```
 Description copied from interface: org.jooq.lambda.Seq
 
 Sort by the results of 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:
 
 ReactiveSeq 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.
```
 
 Subscription next = LazyFutureStream.of(1,2,3,4)
 					 .forEachX(2,System.out::println);
 
 System.out.println("First batch processed!");
 
 next.request(2);
 
 System.out.println("Second batch processed!");
 
 //prints
 1
 2
 First batch processed!
 3
 4 
 Second batch processed!
 
 
```
 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
```
 
 Subscription next = LazyFutureStream.of(()->1,()->2,()->{throw new RuntimeException()},()->4)
 .map(Supplier::get)
 					 .forEachXWithError(2,System.out::println, e->e.printStackTrace());
 
 System.out.println("First batch processed!");
 
 next.request(2);
 
 System.out.println("Second batch processed!");
 
 //prints
 1
 2
 First batch processed!
 
 RuntimeException Stack Trace on System.err
 
 4 
 Second batch processed!
 
 
```
 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
 
 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.
```
 
 Subscription next = LazyFurtureStream.of(()->1,()->2,()->{throw new RuntimeException()},()->4)
 .map(Supplier::get)
 					 .forEachXEvents(2,System.out::println, e->e.printStackTrace(),()->System.out.println("the end!"));
 
 System.out.println("First batch processed!");
 
 next.request(2);
 
 System.out.println("Second batch processed!");
 
 //prints
 1
 2
 First batch processed!
 
 RuntimeException Stack Trace on System.err
 
 4 
 Second batch processed!
 The end!
 
 
```
 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,
```
 
 Subscription next = LazyFutureStream.of(()->1,()->2,()->{throw new RuntimeException()},()->4)
 .map(Supplier::get)
 					 .forEachWithError(System.out::println, e->e.printStackTrace());
 
 System.out.println("processed!");
 
 
 
 //prints
 1
 2
 RuntimeException Stack Trace on System.err
 4
 processed!
 
 
 
```
 Specified by:
 
 forEachWithError in interface ReactiveStreamsTerminalOperations
 
 Parameters:
 
 consumerElement - 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.
```
 
 Subscription next = LazyFutureStream.of(()->1,()->2,()->{throw new RuntimeException()},()->4)
 .map(Supplier::get)
 					 .forEachEvents(System.out::println, e->e.printStackTrace(),()->System.out.println("the end!"));
 
 System.out.println("processed!");
 
 
 //prints
 1
 2
 RuntimeException Stack Trace on System.err
 4 
 processed!
 
 
 
 
```
 Specified by:
 
 forEachEvent in interface ReactiveStreamsTerminalOperations
 
 Parameters:
 
 consumerElement - 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
 
 See Also:
 
 Stream.of(Object)
 - 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
 
 See Also:
 
 Stream.of(Object)
 - 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
 
 See Also:
 
 Stream.empty()
 - 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.To

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

zip

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