FutureStream (cyclops-react 2.0.0-MI1 API)

All Superinterfaces:

java.lang.AutoCloseable, BaseSimpleReactStream, java.util.stream.BaseStream<U,java.util.stream.Stream>, BlockingStream, ConfigurableStream<U,com.aol.cyclops2.internal.react.async.future.FastFuture>, Convert<Higher<ReactiveSeq.µ,U>>, ConvertableSequence, ConvertableToReactiveSeq, CyclopsCollectable, ExtendedTraversable, FilterableTransformable, Filters, Fn1<java.lang.Long,U>, FoldableTraversable, Folds, java.util.function.Function<java.lang.Long,U>, org.jooq.lambda.function.Function1<java.lang.Long,U>, FutureStreamSynchronousPublisher, Higher<ReactiveSeq.µ,U>, java.lang.Iterable, IterableFilterable, LazySimpleReactStream, LazyStream, LazyToQueue, OnEmpty, OnEmptySwitch<U,java.util.stream.Stream>, org.reactivestreams.Publisher, ReactiveSeq, ReactiveStreamsTerminalOperations, Sequential, java.util.stream.Stream, To<ReactiveSeq>, ToQueue, ToStream, Transformable, TransformerTraversable, Traversable, Unit, Unwrapable, Zippable
```
public interface FutureStream
extends LazySimpleReactStream, LazyStream, ReactiveSeq, LazyToQueue, ConfigurableStream<U,com.aol.cyclops2.internal.react.async.future.FastFuture>, FutureStreamSynchronousPublisher
```

Nested Class Summary
- Nested classes/interfaces inherited from interface cyclops.stream.ReactiveSeq
 ReactiveSeq.µ, ReactiveSeq.Instances
- Nested classes/interfaces inherited from interface java.util.stream.Stream
 java.util.stream.Stream.Builder<T>
- Nested classes/interfaces inherited from interface cyclops.function.Fn1
 Fn1.FunctionalOperations<T1,R>

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default OperationsOnFutures<U>`	`actOnFutures()` FutureStream operators act on the results of the previous stage by default.
`default AnyMSeq<Witness.reactiveSeq,U>`	`anyM()`
`default FutureStream<U>`	`append(java.lang.Iterable<? extends U> other)`
`default FutureStream<U>`	`append(U... values)` Append values to the take of this ReactiveSeq
`default FutureStream<U>`	`appendS(java.util.stream.Stream<? extends U> other)` Append Stream to this ReactiveSeq
`default FutureStream<U>`	`async()`
`default FutureStream<U>`	`boundedWaitFree(int size)` Use an Agrona ManyToOneConcurrentArrayQueue for the next operations (wait-free, mechanical sympathy).
`default LazyReact`	`builder()`
`default LazyReact`	`builder(int maxActiveTasks, java.util.concurrent.Executor exec)`
`default FutureStream<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> FutureStream<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 FutureStream<java.util.Collection<U>>`	`chunkSinceLastRead()`
`default void`	`closeAll()` closes all open queues.
`default <R> FutureStream<R>`	`coflatMap(java.util.function.Function<? super ReactiveSeq<U>,? extends R> fn)` coflatMap pattern, can be used to perform lazy reductions / collections / folds and other terminal operations
`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)` Performs a mutable reduction operation on the elements of this stream.
`default <A,R> FutureStream<R>`	`collectSeq(java.util.stream.Collector<? super U,A,R> c)`
`default FutureStream<ReactiveSeq<U>>`	`combinations()` `FutureStream.of(1,2,3).combinations() //FutureStream[SequenceM[],SequenceM[1],SequenceM[2],SequenceM[3].SequenceM[1,2],SequenceM[1,3],SequenceM[2,3] ,SequenceM[1,2,3]]`
`default FutureStream<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 FutureStream<U>`	`concat(java.util.stream.Stream<? extends U> other)` Concatenate two streams operating on the underlying futures rather than results.
`default FutureStream<U>`	`concat(U... other)` Concatenate two streams.
`default FutureStream<U>`	`concat(U other)` Concatenate two streams operating on the underlying futures rather than results.
`default FutureStream<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<FutureStream<U>>`	`copy(int times)` Copy this Stream the specified number of times
`default long`	`count()` Returns the count of elements in this stream.
`default <U1> FutureStream<org.jooq.lambda.tuple.Tuple2<U,U1>>`	`crossApply(java.util.function.Function<? super U,? extends java.lang.Iterable<? extends U1>> function)`
`default <T> FutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`crossJoin(java.util.stream.Stream<? extends T> other)` Cross join 2 streams into one.
`default FutureStream<U>`	`cycle()` Create a Stream that infinitely cycles this Stream
`default FutureStream<U>`	`cycle(long times)` Create a Stream that finitely cycles this Stream, provided number of times
`default FutureStream<U>`	`cycle(Monoid<U> m, long times)` Convert to a Stream with the result of a reduction operation repeated specified times
`default FutureStream<U>`	`cycleUntil(java.util.function.Predicate<? super U> predicate)` Repeat in a Stream until specified predicate holds
`default FutureStream<U>`	`cycleWhile(java.util.function.Predicate<? super U> predicate)` Repeat in a Stream while specified predicate holds
`default FutureStream<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 FutureStream<U>`	`deleteBetween(int start, int end)` Delete elements between given indexes in a Stream
`default FutureStream<U>`	`distinct()`
`default <R> FutureStream<U>`	`distinct(java.util.function.Function<? super U,? extends R> keyExtractor)`
`default FutureStream<U>`	`drop(long drop)` `assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));`
`default FutureStream<U>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the take of this Traversable
`default FutureStream<U>`	`dropUntil(java.util.function.Predicate<? super U> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`default FutureStream<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<ReactiveSeq<U>,ReactiveSeq<U>>`	`duplicate()` Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`default org.jooq.lambda.tuple.Tuple2<FutureStream<U>,FutureStream<U>>`	`duplicateFutureStream()`
`default FutureStream<org.jooq.lambda.tuple.Tuple2<U,java.lang.Long>>`	`elapsed()` `FutureStream.of(1,2,3,4,5) .elapsed() .forEach(System.out::println);`
`static <T> FutureStream<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 FutureStream<U>`	`filter(java.util.function.Predicate<? super U> p)` Removes elements that do not match the supplied predicate from the dataflow
`default FutureStream<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 FutureStream<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> FutureStream<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> FutureStream<R>`	`flatMapAnyM(java.util.function.Function<? super U,AnyM<Witness.stream,? extends R>> flatFn)` Allows flatMap return type to be any Monad type
`default <R> FutureStream<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> FutureStream<R>`	`flatMapI(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> FutureStream<R>`	`flatMapP(java.util.function.Function<? super U,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`default <R> FutureStream<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)`
`static <T1> FutureStream<T1>`	`flatten(ReactiveSeq<? extends java.util.stream.Stream<? extends T1>> nested)`
`default FutureStream<U>`	`fold(Monoid<U> monoid)`
`default <R> Future<R>`	`foldFuture(java.util.function.Function<? super FoldableTraversable<U>,? extends R> fn)`
`default <R> R`	`foldRight(R identity, java.util.function.BiFunction<? super U,? super R,? extends R> accumulator)` Immutable reduction from right to left
`default void`	`forEach(java.util.function.Consumer<? super U> c)` Performs an action for each element of this stream.
`default <X extends java.lang.Throwable> void`	`forEach(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> void`	`forEach(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 <X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEach(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`	`forEach(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.
`default <X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEach(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 <R1,R> FutureStream<R>`	`forEach2(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.BiFunction<? super U,? super R1,? extends R> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied stream
`default <R1,R> FutureStream<R>`	`forEach2(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.BiFunction<? super U,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super U,? super R1,? extends R> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied stream
`default <R1,R2,R> FutureStream<R>`	`forEach3(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.BiFunction<? super U,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2, Fn3<? super U,? super R1,? super R2,? extends R> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`default <R1,R2,R> FutureStream<R>`	`forEach3(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.BiFunction<? super U,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2, Fn3<? super U,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super U,? super R1,? super R2,? extends R> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`default <R1,R2,R3,R> FutureStream<R>`	`forEach4(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.BiFunction<? super U,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2, Fn3<? super U,? super R1,? super R2,? extends java.util.stream.BaseStream<R3,?>> stream3, Fn4<? super U,? super R1,? super R2,? super R3,? extends R> yieldingFunction)` Perform a four level nested internal iteration over this Stream and the supplied streams
`default <R1,R2,R3,R> FutureStream<R>`	`forEach4(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.BiFunction<? super U,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2, Fn3<? super U,? super R1,? super R2,? extends java.util.stream.BaseStream<R3,?>> stream3, Fn4<? super U,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super U,? super R1,? super R2,? super R3,? extends R> yieldingFunction)` Perform a four level nested internal iteration over this Stream and the supplied streams
`default void`	`forEachOrdered(java.util.function.Consumer<? super U> action)`
`static <T> FutureStream<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> FutureStream<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> FutureStream<R>`	`fromStream(java.util.stream.Stream<R> stream)`
`default <R> FutureStream<R>`	`fromStreamOfFutures(java.util.stream.Stream<com.aol.cyclops2.internal.react.async.future.FastFuture<R>> stream)`
`default ReactiveStreamsTerminalFutureOperations<U>`	`futureOperations()`
`default ReactiveStreamsTerminalFutureOperations<U>`	`futureOperations(java.util.concurrent.Executor ex)`
`static FutureStream<java.lang.Void>`	`generate()` Generate an infinite Stream of null values that runs on the current thread
`static <T> FutureStream<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> FutureStream<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>> FutureStream<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 FutureStream<ListX<U>>`	`grouped(int groupSize)` Group elements in a Stream
`default <C extends java.util.Collection<? super U>> FutureStream<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 FutureStream<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>> FutureStream<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 <C extends java.util.Collection<? super U>,R> FutureStream<R>`	`groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)`
`default FutureStream<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>> FutureStream<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 <C extends java.util.Collection<? super U>,R> FutureStream<R>`	`groupedByTime(long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)`
`default <C extends java.util.Collection<U>,R> FutureStream<R>`	`groupedStatefullyUntil(java.util.function.BiPredicate<C,? super U> predicate, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)`
`default FutureStream<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 <C extends java.util.Collection<U>,R> FutureStream<R>`	`groupedStatefullyWhile(java.util.function.BiPredicate<C,? super U> predicate, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)`
`default FutureStream<ListX<U>>`	`groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super U>,? super U> predicate)`
`default FutureStream<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>> FutureStream<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 FutureStream<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>> FutureStream<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 FutureStream 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> FutureStream<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 FutureStream<U>`	`insertAt(int pos, U... values)` Insert data into a stream at given position
`default FutureStream<U>`	`insertAtS(int pos, java.util.stream.Stream<U> stream)` Insert a Stream into the middle of this stream at the specified position
`default FutureStream<U>`	`intersperse(U value)` Returns a stream with a given value interspersed between any two values of this stream.
`default boolean`	`isParallel()`
`static <T> FutureStream<T>`	`iterate(T seed, java.util.function.UnaryOperator<T> f)`
`default com.aol.cyclops2.internal.react.stream.CloseableIterator<U>`	`iterator()`
`default FutureStream<U>`	`jitter(long jitterInNanos)` Introduce a random delay between events in a stream Can be used to prevent behaviour synchronizing within a system
`default <R> FutureStream<R>`	`jooλ(java.util.function.Function<? super org.jooq.lambda.Seq<U>,? extends org.jooq.lambda.Seq<R>> mapper)`
`static <T> FutureStream<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> FutureStream<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> FutureStream<T>`	`lazyFutureStream(java.util.Iterator<T> iterator)` Wrap an Iterator into a FutureStream that runs on the current thread
`static <T> FutureStream<T>`	`lazyFutureStream(java.util.stream.Stream<T> stream)` Wrap a Stream into a FutureStream that runs on the current thread
`static <T> FutureStream<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> FutureStream<T>`	`lazyFutureStreamFromIterable(java.lang.Iterable<T> iterable)` Wrap an Iterable into a FutureStream that runs on the current thread
`default <T> FutureStream<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 FutureStream<U>`	`limit(long maxSize)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`default FutureStream<U>`	`limit(long time, java.util.concurrent.TimeUnit unit)` Return all elements until specified time period has elapsed
`default FutureStream<U>`	`limitLast(int num)` Limit results to the last x elements in a ReactiveSeq
`default FutureStream<U>`	`limitUntil(java.util.function.Predicate<? super U> predicate)` Returns a stream limited to all elements for which a predicate evaluates to false.
`default FutureStream<U>`	`limitWhile(java.util.function.Predicate<? super U> predicate)` Returns a stream limited to all elements for which a predicate evaluates to true.
`default FutureStream<U>`	`limitWhileClosed(java.util.function.Predicate<? super U> predicate)`
`default <R> FutureStream<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)`
`FutureStream<U>`	`maxActive(int concurrentTasks)` Configure the max active concurrent tasks.
`default <R> FutureStream<R>`	`mergeLatest(FutureStream<?>... 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.
`static <T1> FutureStream<T1>`	`narrow(FutureStream<? extends T1> broad)`
`default FutureStream<U>`	`notNull()` Filter elements retaining only values which are not null
`static <T> FutureStream<T>`	`of(T... values)` Create a sequential synchronous stream that runs on the current thread
`static <T> FutureStream<T>`	`of(T value)` Create a sequential synchronous stream that runs on the current thread
`default <U> FutureStream<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`default FutureStream<U>`	`onClose(java.lang.Runnable closeHandler)`
`default FutureStream<U>`	`onEmpty(U value)` Produce this stream, or an alternative stream from the `value`, in case this stream is empty.
`default FutureStream<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 FutureStream<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> FutureStream<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 FutureStream<U>`	`onePer(long time, java.util.concurrent.TimeUnit unit)` Slow emissions down, emiting one element per specified time period
`default FutureStream<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 FutureStream<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 <U1> FutureStream<org.jooq.lambda.tuple.Tuple2<U,U1>>`	`outerApply(java.util.function.Function<? super U,? extends java.lang.Iterable<? extends U1>> function)`
`default FutureStream<U>`	`parallel()`
`default <R> FutureStream<R>`	`parallel(java.util.function.Function<? super java.util.stream.Stream<U>,? extends java.util.stream.Stream<R>> fn)`
`static <U> FutureStream<U>`	`parallel(U... array)` Construct an parallel FutureStream from specified array, using the configured standard parallel thread pool.
`default org.jooq.lambda.tuple.Tuple2<ReactiveSeq<U>,ReactiveSeq<U>>`	`partition(java.util.function.Predicate<? super U> predicate)` Partition a stream in two given a predicate.
`default org.jooq.lambda.tuple.Tuple2<FutureStream<U>,FutureStream<U>>`	`partitionFutureStream(java.util.function.Predicate<? super U> predicate)` Partition an FutureStream into two LazyFutureStreams given a predicate.
`default FutureStream<U>`	`peek(java.util.function.Consumer<? super U> consumer)` Peek asynchronously at the results in the current stage.
`default FutureStream<U>`	`peekSync(java.util.function.Consumer<? super U> consumer)` Synchronous peek operator
`default FutureStream<ReactiveSeq<U>>`	`permutations()` Generate the permutations based on values in the FutureStream Makes use of Streamable to store intermediate stages in a collection
`default FutureStream<U>`	`prepend(java.lang.Iterable<? extends U> other)`
`default FutureStream<U>`	`prepend(U... values)` Prepend given values to the skip of the Stream
`default FutureStream<U>`	`prependS(java.util.stream.Stream<? extends U> other)` 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> FutureStream<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> FutureStream<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> FutureStream<U>`	`recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<? super EX,? extends U> fn)` Recover from a particular exception type
`default FutureStream<U>`	`recover(java.util.function.Function<? super 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 FutureStream<U>`	`remove(U t)` Remove all occurances of the specified element from the SequenceM
`default <R> FutureStream<R>`	`retry(java.util.function.Function<? super U,? extends R> fn)` Will execute this phase on the RetryExecutor (default or user supplied).
`default FutureStream<U>`	`reverse()` Reverse a stream.
`default <T> FutureStream<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 FutureStream<U>`	`scanLeft(Monoid<U> monoid)` Scan left using supplied Monoid
`default <T> FutureStream<T>`	`scanLeft(T seed, java.util.function.BiFunction<? super T,? super U,? extends T> function)` Scan a stream to the left.
`default FutureStream<U>`	`scanRight(Monoid<U> monoid)` Scan right
`default <R> FutureStream<R>`	`scanRight(R seed, java.util.function.BiFunction<? super U,? super R,? extends R> function)` Scan a stream to the right.
`default FutureStream<U>`	`self(java.util.function.Consumer<FutureStream<U>> consumer)` Give a consumer access to this Stream
`default FutureStream<U>`	`sequential()`
`default <K> java.util.Map<K,FutureStream<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 FutureStream<U>`	`shuffle()` Shuffle a stream // e.g.
`default FutureStream<U>`	`shuffle(java.util.Random random)` Shuffle a stream using specified source of randomness // e.g.
`default FutureStream<U>`	`skip(long n)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`default FutureStream<U>`	`skip(long time, java.util.concurrent.TimeUnit unit)` Skip all elements until specified time period has passed
`default FutureStream<U>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`default FutureStream<U>`	`skipUntil(java.util.function.Predicate<? super U> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to false.
`default FutureStream<U>`	`skipWhile(java.util.function.Predicate<? super U> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to true.
`default FutureStream<U>`	`skipWhileClosed(java.util.function.Predicate<? super U> predicate)`
`default FutureStream<U>`	`slice(long from, long to)`
`default FutureStream<PVectorX<U>>`	`sliding(int size)` Create a sliding view over this Stream
`default FutureStream<PVectorX<U>>`	`sliding(int size, int increment)` Create a sliding view over this Stream
`default FutureStream<U>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`default FutureStream<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>> FutureStream<U>`	`sorted(java.util.function.Function<? super U,? extends R> function)`
`default <U1> FutureStream<U>`	`sorted(java.util.function.Function<? super U,? extends U1> function, java.util.Comparator<? super U1> comparator)`
`default org.jooq.lambda.tuple.Tuple2<ReactiveSeq<U>,ReactiveSeq<U>>`	`splitAt(int where)` Split at supplied location
`default org.jooq.lambda.tuple.Tuple2<java.util.Optional<U>,ReactiveSeq<U>>`	`splitAtHead()` Split a Stream at it's head (similar to headAndTail)
`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()` Returns a spliterator for the elements of this stream.
`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 FutureStream<U>`	`subStream(int start, int end)` Return a Stream with elements before the provided skip index removed, and elements after the provided take index removed
`default <R> FutureStream<R>`	`switchOnNextValue(java.util.stream.Stream<FutureStream> 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 FutureStream<U>`	`sync()`
`default FutureStream<U>`	`take(long take)` `assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));`
`default FutureStream<U>`	`takeRight(int num)` Generate a new Traversable that takes the specified number elements from the take of this Traversable
`default FutureStream<U>`	`takeUntil(java.util.function.Predicate<? super U> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`default FutureStream<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> FutureStream<R>`	`then(java.util.function.Function<? super U,? extends R> fn)` React transform Unlike 'with' this method is fluent, and returns another Stage Builder that can represent the next stage in the dataflow.
`default <R> FutureStream<R>`	`then(java.util.function.Function<? super U,? extends R> fn, java.util.concurrent.Executor service)`
`default <R> FutureStream<R>`	`thenSync(java.util.function.Function<? super U,? extends R> fn)`
`default java.lang.Object[]`	`toArray()`
`default <A> A[]`	`toArray(java.util.function.IntFunction<A[]> generator)`
`default <C extends java.util.Collection<U>> C`	`toCollection(java.util.function.Supplier<C> collectionFactory)`
`default java.util.concurrent.CompletableFuture<ListX<U>>`	`toCompletableFuture()`
`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()`
`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()`
`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> FutureStream<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 FutureStream<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 FutureStream<U>`	`unordered()`
`default <R> R`	`unwrap()` START SEQUENCEM
`FutureStream<U>`	`withAsync(boolean async)`
`<R> FutureStream<R>`	`withLastActive(com.aol.cyclops2.internal.react.stream.LazyStreamWrapper<R> streamWrapper)`
`FutureStream<U>`	`withLazyCollector(java.util.function.Supplier<LazyResultConsumer<U>> lazy)`
`FutureStream<U>`	`withQueueFactory(QueueFactory<U> queue)`
`FutureStream<U>`	`withRetrier(com.nurkiewicz.asyncretry.RetryExecutor retry)`
`FutureStream<U>`	`withSubscription(Continueable sub)`
`FutureStream<U>`	`withTaskExecutor(java.util.concurrent.Executor e)`
`default FutureStream<U>`	`xPer(int x, long time, java.util.concurrent.TimeUnit unit)` Allows x (specified number of) emissions with a time period before stopping emmissions until specified time has elapsed since last emission
`default <T> FutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`zip(java.lang.Iterable<? extends T> other)` Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
`default <T,R> FutureStream<R>`	`zip(java.lang.Iterable<? extends T> other, java.util.function.BiFunction<? super U,? super T,? extends R> zipper)` Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
`default <S,R> FutureStream<org.jooq.lambda.tuple.Tuple3<U,S,R>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends R> third)` zip 3 Streams into one
`default <T2,T3,T4> FutureStream<org.jooq.lambda.tuple.Tuple4<U,T2,T3,T4>>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)` zip 4 Streams into 1
`default <T2,R> FutureStream<R>`	`zipP(org.reactivestreams.Publisher<? extends T2> publisher, java.util.function.BiFunction<? super U,? super T2,? extends R> fn)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`default <T> FutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`zipS(java.util.stream.Stream<? extends T> other)` Zip 2 streams into one
`default <T,R> FutureStream<R>`	`zipS(java.util.stream.Stream<? extends T> other, java.util.function.BiFunction<? super U,? super T,? extends R> zipper)` Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
`default FutureStream<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.cyclops2.types.futurestream.LazySimpleReactStream
assureSimpleReactException, copySimpleReactStream, filterSync, flatMapToCompletableFuture, flatMapToCompletableFutureSync, getLastActive, handleExceptions, streamCompletableFutures, withErrorHandler

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

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

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

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

Methods inherited from interface cyclops.stream.ReactiveSeq
allMatch, anyMatch, append, collect, combinations, concat, concat, concat, concat, concatDoubles, concatInts, concatLongs, defered, deferedI, deferedP, doubles, elementAt, fill, filterInts, filterLongs, filterLongs, flatMapDoubles, flatMapInts, flatMapLongs, flatten, flattenI, flattenO, foldJooλ, foldParallel, foldParallel, foldRight, foldRight, foldRightMapToType, format, fromCharSequence, fromDoubleStream, fromIntStream, fromIterable, fromIterator, fromList, fromLongStream, fromPublisher, fromSpliterator, fromSpliterator, fromStream, get, groupBy, grouped, grouped, headAndTail, hotStream, ints, isEmpty, join, join, join, limitDouble, limitInts, limitLongs, limitUntilClosed, longs, mapDoubles, mapInts, mapLongs, mapReduce, mapReduce, max, min, narrowK, noneMatch, ofDoubles, ofInts, ofLongs, oneShotList, oneShotStream, parallel, pausableHotStream, prepend, primedHotStream, primedPausableHotStream, print, print, printErr, printOut, pushable, range, rangeLong, reduce, reduce, reduce, removeAllS, removeAllS, removeAllS, retainAllS, retainAllS, retainAllS, retry, reversedListOf, reversedOf, schedule, scheduleFixedDelay, scheduleFixedRate, seq, single, single, singleOptional, size, skipDoubles, skipInts, skipLongs, skipUntilClosed, subscriber, timestamp, unfold, unit, unzip, unzip3, unzip4, xMatch, zip, zip3, zip4, zipP, zipWith, zipWithP, zipWithS

Methods inherited from interface com.aol.cyclops2.types.To
to

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

Methods inherited from interface java.util.stream.BaseStream
close

Methods inherited from interface com.aol.cyclops2.types.FoldableTraversable
apply, foldFuture, foldLazy, foldTry, runFuture, runLazy, visit

Methods inherited from interface cyclops.function.Fn1
andThen, andThen, bind, compose, functionOps, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, product, reader, λ, λv

Methods inherited from interface org.jooq.lambda.function.Function1
apply, applyPartially, applyPartially, curry, curry, from, toFunction

Methods inherited from interface java.util.function.Function
identity

Methods inherited from interface com.aol.cyclops2.types.stream.CyclopsCollectable
avg, avgDouble, avgInt, avgLong, bitAnd, bitAndInt, bitAndLong, bitOr, bitOrInt, bitOrLong, collectable, commonPrefix, commonSuffix, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, max, max, maxAll, maxAll, maxAll, maxAll, maxAllBy, maxAllBy, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, minAll, minAll, minAll, minAll, minAllBy, minAllBy, minBy, minBy, mode, modeAll, modeAllBy, modeBy, percentile, percentile, percentileBy, percentileBy, sum, sumDouble, sumInt, sumLong, toList, toMap, toMap, toSet, toString, toString

Methods inherited from interface com.aol.cyclops2.types.Folds
foldLeft, foldLeft, foldLeft, foldLeft

Methods inherited from interface com.aol.cyclops2.types.stream.ConvertableSequence
toDequeX, toFutureStream, toFutureStream, toListX, toMapX, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toValue

Methods inherited from interface com.aol.cyclops2.types.Traversable
traversable, unitIterator

Methods inherited from interface com.aol.cyclops2.types.stream.ToStream
futureStream, getStreamable, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream

Methods inherited from interface com.aol.cyclops2.types.TransformerTraversable
groupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT

Methods inherited from interface com.aol.cyclops2.hkt.Higher
apply_, apply, transform

Methods inherited from interface com.aol.cyclops2.hkt.Convert
convert

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

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

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

- Method Detail
 - builder
```
default LazyReact builder(int maxActiveTasks,
 java.util.concurrent.Executor exec)
```
 - builder
```
default LazyReact builder()
```
 - foldFuture
```
default <R> Future<R> foldFuture(java.util.function.Function<? super FoldableTraversable,? extends R> fn)
```
 - futureOperations
```
default ReactiveStreamsTerminalFutureOperations futureOperations(java.util.concurrent.Executor ex)
```
 Specified by:
 
 futureOperations in interface ReactiveSeq
 - futureOperations
```
default ReactiveStreamsTerminalFutureOperations futureOperations()
```
 - collectSeq
```
default <A,R> FutureStream<R> collectSeq(java.util.stream.Collector<? super U,A,R> c)
```
 Specified by:
 
 collectSeq in interface ReactiveSeq
 - fold
```
default FutureStream fold(Monoid monoid)
```
 Specified by:
 
 fold in interface ReactiveSeq
 - crossApply
```
default <U1> FutureStream<org.jooq.lambda.tuple.Tuple2<U,U1>> crossApply(java.util.function.Function<? super U,? extends java.lang.Iterable<? extends U1>> function)
```
 - outerApply
```
default <U1> FutureStream<org.jooq.lambda.tuple.Tuple2<U,U1>> outerApply(java.util.function.Function<? super U,? extends java.lang.Iterable<? extends U1>> function)
```
 - appendS
```
default FutureStream appendS(java.util.stream.Stream<? extends U> other)
```
 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:
 
 appendS in interface ReactiveSeq
 
 Returns:
 
 ReactiveSeq with Stream appended
 - append
```
default FutureStream append(java.lang.Iterable<? extends U> other)
```
 Specified by:
 
 append in interface ReactiveSeq
 - prependS
```
default FutureStream prependS(java.util.stream.Stream<? extends U> other)
```
 Description copied from interface: ReactiveSeq
 Prepend Stream to this ReactiveSeq
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3)
 .prependS(of(100, 200, 300))
 .map(it -> it + "!!")
 .collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
 
 
```
 Specified by:
 
 prependS in interface ReactiveSeq
 
 Specified by:
 
 prependS in interface Traversable
 
 Parameters:
 
 other - to Prepend
 
 Returns:
 
 ReactiveSeq with Stream prepended
 - prepend
```
default FutureStream prepend(java.lang.Iterable<? extends U> other)
```
 Specified by:
 
 prepend in interface ReactiveSeq
 - cycle
```
default FutureStream cycle(long times)
```
 Create a Stream that finitely cycles this Stream, provided number of times
```
 
 assertThat(FutureStream.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
 - skipWhileClosed
```
default FutureStream skipWhileClosed(java.util.function.Predicate<? super U> predicate)
```
 Specified by:
 
 skipWhileClosed in interface ReactiveSeq
 - limitWhileClosed
```
default FutureStream limitWhileClosed(java.util.function.Predicate<? super U> predicate)
```
 Specified by:
 
 limitWhileClosed in interface ReactiveSeq
 - sorted
```
default <U1> FutureStream sorted(java.util.function.Function<? super U,? extends U1> function,
 java.util.Comparator<? super U1> comparator)
```
 Specified by:
 
 sorted in interface ReactiveSeq
 - coflatMap
```
default <R> FutureStream<R> coflatMap(java.util.function.Function<? super ReactiveSeq,? extends R> fn)
```
 coflatMap pattern, can be used to perform lazy reductions / collections / folds and other terminal operations
```
 
 
 FutureStream.of(1,2,3)
 .map(i->i*2)
 .coflatMap(s -> s.reduce(0,(a,b)->a+b))
 
 //FutureStream[12]
 
 
```
 Specified by:
 
 coflatMap in interface ReactiveSeq
 
 Parameters:
 
 fn -
 
 Returns:
 - filterNot
```
default FutureStream filterNot(java.util.function.Predicate<? super U> fn)
```
 Description copied from interface: Filters
 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 Filters
 
 Specified by:
 
 filterNot in interface ReactiveSeq
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - notNull
```
default FutureStream notNull()
```
 Description copied from interface: Filters
 Filter elements retaining only values which are not null
```
 
 
 of(1,2,null,4).nonNull();
 
 //[1,2,4]
 
 
 
```
 Specified by:
 
 notNull in interface Filters
 
 Specified by:
 
 notNull in interface ReactiveSeq
 
 Returns:
 
 Filters with nulls removed
 - trampoline
```
default <R> FutureStream<R> trampoline(java.util.function.Function<? super U,? extends Trampoline<? extends R>> mapper)
```
 Description copied from interface: ReactiveSeq
 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 ReactiveSeq
 
 Specified by:
 
 trampoline in interface Transformable
 
 Parameters:
 
 mapper - TCO Transformation function
 
 Returns:
 
 Transformable 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: Folds
 
 Immutable reduction from right to left
 
 Specified by:
 
 foldRight in interface Folds
 
 Specified by:
 
 foldRight in interface ReactiveSeq
 
 Parameters:
 
 identity - Identity value for the combiner function (leaves the input unchanged)
 
 accumulator - Combining function
 
 Returns:
 
 Reduced value
 - zipP
```
default <T2,R> FutureStream<R> zipP(org.reactivestreams.Publisher<? extends T2> publisher,
 java.util.function.BiFunction<? super U,? super T2,? extends R> fn)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
 
 Specified by:
 
 zipP in interface ReactiveSeq
 
 Specified by:
 
 zipP in interface Zippable
 
 Parameters:
 
 publisher - to combine with
 
 fn - Zip / combining function
 
 Returns:
 
 Combined zippable
 - elapsed
```
default FutureStream<org.jooq.lambda.tuple.Tuple2<U,java.lang.Long>> elapsed()
```
```
 
 FutureStream.of(1,2,3,4,5)
 				 		.elapsed()
 				 	.forEach(System.out::println);
 
 
```
 Specified by:
 
 elapsed in interface ReactiveSeq
 
 Returns:
 
 FutureStream that adds the time between elements in millis to each element
 - combine
```
default FutureStream 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 FutureStream onEmptySwitch(java.util.function.Supplier<? extends java.util.stream.Stream> switchTo)
```
 If this SequenceM is empty replace it with a another Stream
```
 
 assertThat(FutureStream.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
 - forEach4
```
default <R1,R2,R3,R> FutureStream<R> forEach4(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.BiFunction<? super U,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2,
 Fn3<? super U,? super R1,? super R2,? extends java.util.stream.BaseStream<R3,?>> stream3,
 Fn4<? super U,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
```
 Description copied from interface: ReactiveSeq
 Perform a four level nested internal iteration over this Stream and the supplied streams
```
 
 
 //ReactiveSeq [1,2]
 
 reactiveSeq.forEach4(a->ListX.range(10,13),
 (a,b)->ListX.of(""+(a+b),"hello world"),
 (a,b,c)->ListX.of(a,b,c)),
 (a,b,c,d)->c+":"a+":"+b);
 

 
 
```
 Specified by:
 
 forEach4 in interface ReactiveSeq
 
 Parameters:
 
 stream1 - Nested Stream to iterate over
 
 stream2 - Nested Stream to iterate over
 
 stream3 - Nested Stream to iterate over
 
 yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
 
 Returns:
 
 ReactiveSeq with elements generated via nested iteration
 - forEach4
```
default <R1,R2,R3,R> FutureStream<R> forEach4(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.BiFunction<? super U,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2,
 Fn3<? super U,? super R1,? super R2,? extends java.util.stream.BaseStream<R3,?>> stream3,
 Fn4<? super U,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
 Fn4<? super U,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
```
 Description copied from interface: ReactiveSeq
 Perform a four level nested internal iteration over this Stream and the supplied streams
```
 
 //ReactiveSeq [1,2,3]
 
 seq.forEach4(a->ReactiveSeq.range(10,13),
 (a,b)->Stream.of(""+(a+b),"hello world"),
 (a,b,c)->Stream.of(a,b,c),
 (a,b,c,d)-> c!=3,
 (a,b,c)->c+":"a+":"+b);
 
 
 
 
 
```
 Specified by:
 
 forEach4 in interface ReactiveSeq
 
 Parameters:
 
 stream1 - Nested Stream to iterate over
 
 stream2 - Nested Stream to iterate over
 
 stream3 - 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:
 
 ReactiveSeq with elements generated via nested iteration
 - forEach3
```
default <R1,R2,R> FutureStream<R> forEach3(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.BiFunction<? super U,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2,
 Fn3<? super U,? super R1,? super R2,? extends R> yieldingFunction)
```
 Description copied from interface: ReactiveSeq
 Perform a three level nested internal iteration over this Stream and the supplied streams
```
 
 ReactiveSeq.of(1,2)
 .forEach3(a->IntStream.range(10,13),
 (a,b)->Stream.of(""+(a+b),"hello world"),
 (a,b,c)->c+":"a+":"+b);
 
 
 //ReactiveSeq[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:
 
 ReactiveSeq with elements generated via nested iteration
 - forEach3
```
default <R1,R2,R> FutureStream<R> forEach3(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.BiFunction<? super U,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2,
 Fn3<? super U,? super R1,? super R2,java.lang.Boolean> filterFunction,
 Fn3<? super U,? super R1,? super R2,? extends R> yieldingFunction)
```
 Description copied from interface: ReactiveSeq
 Perform a three level nested internal iteration over this Stream and the supplied streams
```
 
 ReactiveSeq.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);
 
 
 //ReactiveSeq[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:
 
 ReactiveSeq with elements generated via nested iteration
 - forEach2
```
default <R1,R> FutureStream<R> forEach2(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.BiFunction<? super U,? super R1,? extends R> yieldingFunction)
```
 Description copied from interface: ReactiveSeq
 Perform a two level nested internal iteration over this Stream and the supplied stream
```
 
 ReactiveSeq.of(1,2,3)
 .forEach2(a->IntStream.range(10,13),
 (a,b)->a+b);
 
 
 //ReactiveSeq[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:
 
 ReactiveSeq with elements generated via nested iteration
 - forEach2
```
default <R1,R> FutureStream<R> forEach2(java.util.function.Function<? super U,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.BiFunction<? super U,? super R1,java.lang.Boolean> filterFunction,
 java.util.function.BiFunction<? super U,? super R1,? extends R> yieldingFunction)
```
 Description copied from interface: ReactiveSeq
 Perform a two level nested internal iteration over this Stream and the supplied stream
```
 
 ReactiveSeq.of(1,2,3)
 .forEach2(a->IntStream.range(10,13),
 (a,b)-> a<3 && b>10,
 (a,b)->a+b);
 
 
 //ReactiveSeq[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:
 
 ReactiveSeq with elements generated via nested iteration
 - remove
```
default FutureStream remove(U t)
```
 Remove all occurances of the specified element from the SequenceM
```
 
 	FutureStream.of(1,2,3,4,5,1,2,3).remove(1)

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


 //FutureStream[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 FutureStream<ReactiveSeq> permutations()
```
 Generate the permutations based on values in the FutureStream 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 FutureStream
 - combinations
```
default FutureStream<ReactiveSeq> combinations()
```
```
 
 FutureStream.of(1,2,3).combinations()

 //FutureStream[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()
```
 FutureStream 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 skip index 1
 Returns:
 
 Access a set of operators that act on the underlying futures in this Stream.
 - iterator
```
default com.aol.cyclops2.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> FutureStream<R> withLastActive(com.aol.cyclops2.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.cyclops2.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 FutureStream<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: ReactiveSeq
 Returns the count of elements in this stream. This is a special case of a reduction and is equivalent to:
```
 return mapToLong(e -> 1L).sum();
 
```
 This is a terminal operation.
 Specified by:
 
 count in interface CyclopsCollectable
 
 Specified by:
 
 count in interface ReactiveSeq
 
 Specified by:
 
 count in interface java.util.stream.Stream
 
 Returns:
 
 the count of elements in this stream
 - withTaskExecutor
```
FutureStream withTaskExecutor(java.util.concurrent.Executor e)
```
 Specified by:
 
 withTaskExecutor in interface ConfigurableStream<U,com.aol.cyclops2.internal.react.async.future.FastFuture>
 
 Specified by:
 
 withTaskExecutor in interface LazySimpleReactStream
 - withRetrier
```
FutureStream withRetrier(com.nurkiewicz.asyncretry.RetryExecutor retry)
```
 Specified by:
 
 withRetrier in interface BaseSimpleReactStream
 
 Specified by:
 
 withRetrier in interface ConfigurableStream<U,com.aol.cyclops2.internal.react.async.future.FastFuture>
 
 Specified by:
 
 withRetrier in interface LazySimpleReactStream
 - withLazyCollector
```
FutureStream withLazyCollector(java.util.function.Supplier<LazyResultConsumer> lazy)
```
 - withQueueFactory
```
FutureStream withQueueFactory(QueueFactory queue)
```
 Specified by:
 
 withQueueFactory in interface BaseSimpleReactStream
 
 Specified by:
 
 withQueueFactory in interface ConfigurableStream<U,com.aol.cyclops2.internal.react.async.future.FastFuture>
 
 Specified by:
 
 withQueueFactory in interface LazySimpleReactStream
 - withSubscription
```
FutureStream withSubscription(Continueable sub)
```
 Specified by:
 
 withSubscription in interface BaseSimpleReactStream
 
 Specified by:
 
 withSubscription in interface ConfigurableStream<U,com.aol.cyclops2.internal.react.async.future.FastFuture>
 
 Specified by:
 
 withSubscription in interface LazySimpleReactStream
 - withAsync
```
FutureStream withAsync(boolean async)
```
 Specified by:
 
 withAsync in interface ConfigurableStream<U,com.aol.cyclops2.internal.react.async.future.FastFuture>
 
 Specified by:
 
 withAsync in interface LazySimpleReactStream
 - forEach
```
default void forEach(java.util.function.Consumer<? super U> c)
```
 Description copied from interface: ReactiveSeq
 
 Performs an action for each element of this stream.
 
 This is a terminal operation.
 
 The behavior of this operation is explicitly nondeterministic. For parallel stream pipelines, this operation does not guarantee to respect the encounter order of the stream, as doing so would sacrifice the benefit of parallelism. For any given element, the action may be performed at whatever time and in whatever thread the library chooses. If the action accesses shared state, it is responsible for providing the required synchronization.
 
 Specified by:
 
 forEach in interface java.lang.Iterable
 
 Specified by:
 
 forEach in interface LazyStream
 
 Specified by:
 
 forEach in interface ReactiveSeq
 
 Specified by:
 
 forEach in interface java.util.stream.Stream
 
 Parameters:
 
 c - a non-interfering action to perform on the elements
 - 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
 - parallel
```
default <R> FutureStream<R> parallel(java.util.function.Function<? super java.util.stream.Stream,? extends java.util.stream.Stream<R>> fn)
```
 Specified by:
 
 parallel in interface ReactiveSeq
 - jooλ
```
default <R> FutureStream<R> jooλ(java.util.function.Function<? super org.jooq.lambda.Seq,? extends org.jooq.lambda.Seq<R>> mapper)
```
 Specified by:
 
 jooλ in interface ReactiveSeq
 - reduce
```
default <T> T reduce(T identity,
 java.util.function.BiFunction<T,? super U,T> accumulator)
```
 Description copied from interface: Folds
 
 An equivalent function to Stream.reduce(Object, BinaryOperator)
 
 Specified by:
 
 reduce in interface Folds
 
 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 Folds is traversed from left to right
 - reduce
```
default U reduce(U identity,
 java.util.function.BinaryOperator accumulator)
```
 Description copied from interface: Folds
 
 An equivalent function to Stream.reduce(Object, BinaryOperator)
 
 Specified by:
 
 reduce in interface Folds
 
 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 Folds 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: Folds
 
 An equivalent function to Stream.reduce(Object, BiFunction, BinaryOperator)
 
 Specified by:
 
 reduce in interface Folds
 
 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: Folds
 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 Folds
 
 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)
```
 Description copied from interface: ReactiveSeq
 Performs a mutable reduction operation on the elements of this stream. A mutable reduction is one in which the reduced value is a mutable result container, such as an ArrayList, and elements are incorporated by updating the state of the result rather than by replacing the result. This produces a result equivalent to:
```
 R result = supplier.get();
 for (T element : this stream)
 accumulator.accept(result, element);
 return result;
 
```
 Like ReactiveSeq.reduce(Object, BinaryOperator), collect operations can be parallelized without requiring additional synchronization.
 
 This is a terminal operation.
 Specified by:
 
 collect in interface LazyStream
 
 Specified by:
 
 collect in interface ReactiveSeq
 
 Specified by:
 
 collect in interface java.util.stream.Stream
 
 Parameters:
 
 supplier - a function that creates a new result container. For a parallel execution, this function may be called multiple times and must return a fresh value each time.
 
 accumulator - an associative, non-interfering, stateless function for incorporating an additional element into a result
 
 combiner - an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function
 
 Returns:
 
 the result of the reduction
 - sync
```
default FutureStream sync()
```
 Specified by:
 
 sync in interface BaseSimpleReactStream
 - async
```
default FutureStream async()
```
 Specified by:
 
 async in interface BaseSimpleReactStream
 - unboundedWaitFree
```
default FutureStream 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:
 
 FutureStream backed by a ConcurrentLinkedQueue
 - boundedWaitFree
```
default FutureStream 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.
```
 
 FutureStream.of(col)
 .boundedWaitFree(110)
 .flatMap(Collection::stream)
 .toList();
 
 
```
 Parameters:
 
 size - Buffer size
 
 Returns:
 
 FutureStream backed by an Agrona ManyToOneConcurrentArrayQueue
 - maxActive
```
FutureStream 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:
 
 FutureStream with new limits set
 - thenSync
```
default <R> FutureStream<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 FutureStream 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 FutureStream 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 Folds
 
 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 FutureStream, will use the same executors
 - map
```
default <R> FutureStream<R> map(java.util.function.Function<? super U,? extends R> mapper)
```
 Description copied from interface: Transformable
 Transform this functor using the supplied transformation function
```
 
 
 
 of(1,2,3).map(i->i*2)
 
 //[2,4,6]
 
 
 
```
 Specified by:
 
 map in interface FilterableTransformable
 
 Specified by:
 
 map in interface ReactiveSeq
 
 Specified by:
 
 map in interface java.util.stream.Stream
 
 Specified by:
 
 map in interface Transformable
 
 Parameters:
 
 mapper - Transformation function
 
 Returns:
 
 Transformed Transformable
 - shard
```
default <K> java.util.Map<K,FutureStream> 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.
```
 

 FutureStream.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 FutureStream 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
```
 
 FutureStream.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 FutureStream 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> FutureStream<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 FutureStream<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
 - groupedBySizeAndTime
```
default <C extends java.util.Collection<? super U>,R> FutureStream<R> groupedBySizeAndTime(int size,
 long time,
 java.util.concurrent.TimeUnit unit,
 java.util.function.Supplier<C> factory,
 java.util.function.Function<? super C,? extends R> finalizer)
```
 Specified by:
 
 groupedBySizeAndTime in interface ReactiveSeq
 - grouped
```
default <C extends java.util.Collection<? super U>> FutureStream<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
```
 
 		FutureStream.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 FutureStream jitter(long jitterInNanos)
```
 Introduce a random delay between events in a stream Can be used to prevent behaviour synchronizing within a system
```
 

 FutureStream.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 FutureStream 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.
```
 
 FutureStream.of(1,2,3,4)
 .fixedDelay(1,TimeUnit.hours);
 
 
```
 Will emit 1 on skip, transform 2 after an hour, 3 after 2 hours and so on. However all 4 numbers will be populated in the Stream immediately.
```
 
 FutureStream.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
 
 Specified by:
 
 fixedDelay in interface Sequential
 
 Parameters:
 
 time - amount of time between emissions
 
 unit - TimeUnit for emissions
 
 Returns:
 
 Next Stage of the Stream
 - onePer
```
default FutureStream onePer(long time,
 java.util.concurrent.TimeUnit unit)
```
 Slow emissions down, emiting one element per specified time period
```
 
 		FutureStream.of(1,2,3,4,5,6)
 						 .onePer(1000,TimeUnit.NANOSECONDS)
 						 .toList();

 

 
```
 Specified by:
 
 onePer in interface ReactiveSeq
 
 Specified by:
 
 onePer in interface Sequential
 
 Parameters:
 
 time - Frequency period of element emission
 
 unit - Time unit for frequency period
 
 Returns:
 
 Stream with emissions slowed down by specified emission frequency
 - xPer
```
default FutureStream xPer(int x,
 long time,
 java.util.concurrent.TimeUnit unit)
```
 Allows x (specified number of) emissions with a time period before stopping emmissions until specified time has elapsed since last emission
```
 
 FutureStream.of(1,2,3,4,5,6)
 				 .xPer(6,100000000,TimeUnit.NANOSECONDS)
 				 .toList();

 

 
```
 Specified by:
 
 xPer in interface ReactiveSeq
 
 Specified by:
 
 xPer in interface Sequential
 
 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 FutureStream<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
```
 
 	FutureStream.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>> FutureStream<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 = FutureStream.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
 - groupedByTime
```
default <C extends java.util.Collection<? super U>,R> FutureStream<R> groupedByTime(long time,
 java.util.concurrent.TimeUnit unit,
 java.util.function.Supplier<C> factory,
 java.util.function.Function<? super C,? extends R> finalizer)
```
 Specified by:
 
 groupedByTime in interface ReactiveSeq
 - then
```
default <R> FutureStream<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> FutureStream<R> then(java.util.function.Function<? super U,? extends R> fn)
```
 Description copied from interface: LazySimpleReactStream
 React transform 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)
 			.transform((it) -> it * 100)
 			.transform((it) -> "*" + it)
 			
 			
 
```
 React transform allows event reactors to be chained. Unlike React with, which returns a collection of Future references, React transform is a fluent interface that returns the React builder - allowing further reactors to be added to the chain. React transform does not block. React with can be called after React transform 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<FutureStream> copy(int times)
```
 Copy this Stream the specified number of times
```
 
 FutureStream.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> FutureStream<R> switchOnNextValue(java.util.stream.Stream<FutureStream> 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
```
 
 	FutureStream<Integer> fast = ... // [1,2,3,4,5,6,7..]
 	FutureStream<Integer> slow = ... // [100,200,300,400,500,600..]

 FutureStream<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> FutureStream<R> mergeLatest(FutureStream<?>... 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
```
 
 	FutureStream<Integer> fast = ... // [1,2,3,4,5,6,7..]
 	FutureStream<Integer> slow = ... // [100,200,300,400,500,600..]

 FutureStream<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 FutureStream 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)
 				.transform(it -> {
 					if (it == 100)
 						throw new RuntimeException("boo!");
 		
 					return it;
 				})
 				.onFail(e -> 1)
 				.transform(it -> "*" + it)
 				.block();	 
 
 
 
 
 
 
```
 In this example onFail recovers from the RuntimeException thrown when the input to the first 'transform' 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 FutureStream 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 FutureStream 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)
 		.transform(it -> it * 100)
 		.transform(it -> {
 			if (it == 100)
 				throw new RuntimeException("boo!");
 
 			return it;
 		})
 		.onFail(e -> 1)
 		.transform(it -> "*" + it)
 		.transform(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 FutureStream peek(java.util.function.Consumer<? super U> consumer)
```
 Description copied from interface: LazySimpleReactStream
 
 Peek asynchronously at the results in the current stage. Current results are passed through to the next stage.
 
 Specified by:
 
 peek in interface BaseSimpleReactStream
 
 Specified by:
 
 peek in interface LazySimpleReactStream
 
 Specified by:
 
 peek in interface ReactiveSeq
 
 Specified by:
 
 peek in interface java.util.stream.Stream
 
 Specified by:
 
 peek in interface Transformable
 
 Parameters:
 
 consumer - That will recieve current results
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - filter
```
default FutureStream filter(java.util.function.Predicate<? super U> p)
```
 Description copied from interface: LazySimpleReactStream
 
 Removes elements that do not match the supplied predicate from the dataflow
 
 Specified by:
 
 filter in interface BaseSimpleReactStream
 
 Specified by:
 
 filter in interface FilterableTransformable
 
 Specified by:
 
 filter in interface Filters
 
 Specified by:
 
 filter in interface LazySimpleReactStream
 
 Specified by:
 
 filter in interface ReactiveSeq
 
 Specified by:
 
 filter in interface java.util.stream.Stream
 
 Parameters:
 
 p - Predicate that will be used to filter elements from the dataflow
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - flatMap
```
default <R> FutureStream<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 function 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 java.util.stream.Stream
 
 Parameters:
 
 flatFn - Function that coverts a value (e.g. a Collection) into a Stream
 
 Returns:
 
 SimpleReactStream
 - flatMapAnyM
```
default <R> FutureStream<R> flatMapAnyM(java.util.function.Function<? super U,AnyM<Witness.stream,? 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-> fromEither5(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> FutureStream<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> FutureStream<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
 
 Specified by:
 
 retry in interface Transformable
 
 Parameters:
 
 fn - Function that will be executed and retried on failure
 
 Returns:
 
 Next Stage in the Strea,
 - fromStream
```
default <R> FutureStream<R> fromStream(java.util.stream.Stream<R> stream)
```
 Specified by:
 
 fromStream in interface BaseSimpleReactStream
 - fromStreamOfFutures
```
default <R> FutureStream<R> fromStreamOfFutures(java.util.stream.Stream<com.aol.cyclops2.internal.react.async.future.FastFuture<R>> stream)
```
 - concat
```
default FutureStream concat(java.util.stream.Stream<? extends U> other)
```
 Concatenate two streams operating on the underlying futures rather than results. // (1, 2, 3, 4, 5, 6) FutureStream.of(1, 2, 3).concat(FutureStream.of(4, 5, 6))
 
 See Also:
 
 ReactiveSeq.concat(Stream[])
 - concat
```
default FutureStream concat(U other)
```
 Concatenate two streams operating on the underlying futures rather than results.
```
 
 // (1, 2, 3, 4)
 FutureStream.of(1, 2, 3).concat(4)
 
 
```
 See Also:
 
 ReactiveSeq.concat(Stream[])
 - concat
```
default FutureStream concat(U... other)
```
 Concatenate two streams. operating on the underlying futures rather than results.
```
 
 // (1, 2, 3, 4, 5, 6)
 FutureStream.of(1, 2, 3).concat(4, 5, 6)
 
 
```
 See Also:
 
 ReactiveSeq.concat(Stream[])
 - cast
```
default  FutureStream cast(java.lang.Class<? extends U> type)
```
 Description copied from interface: ReactiveSeq
 
 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 ReactiveSeq
 
 Specified by:
 
 cast in interface Transformable
 - ofType
```
default  FutureStream ofType(java.lang.Class<? extends U> type)
```
 Keep only those elements in a stream that are of a given type. FutureStream.of(1, "a", 2, "b", 3).ofType(Integer.class) gives a Stream of (1,2,3) FutureStream.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 Filters
 
 Specified by:
 
 ofType in interface ReactiveSeq
 - intersperse
```
default FutureStream 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) FutureStream.of(1, 2, 3, 4).intersperse(0)
 
 Specified by:
 
 intersperse in interface BaseSimpleReactStream
 
 Specified by:
 
 intersperse in interface ReactiveSeq
 
 Specified by:
 
 intersperse in interface Traversable
 
 See Also:
 
 #intersperse(Stream, Object)
 - limit
```
default FutureStream 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 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 FutureStream drop(long drop)
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
 Specified by:
 
 drop in interface ReactiveSeq
 
 Specified by:
 
 drop in interface Traversable
 
 Parameters:
 
 drop - Number of elemenets to drop
 
 Returns:
 
 Traversable with specified number of elements skipped
 - take
```
default FutureStream take(long take)
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));
 
```
 Specified by:
 
 take in interface ReactiveSeq
 
 Specified by:
 
 take in interface Traversable
 
 Parameters:
 
 take - Limit element size to num
 
 Returns:
 
 Monad converted to Stream with elements up to num
 - takeWhile
```
default FutureStream 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 FutureStream 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 FutureStream 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 FutureStream 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 FutureStream dropRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops the specified number elements from the take 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 take of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - takeRight
```
default FutureStream takeRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes the specified number elements from the take 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 take of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - skip
```
default FutureStream 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 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 FutureStream distinct()
```
 Specified by:
 
 distinct in interface ReactiveSeq
 
 Specified by:
 
 distinct in interface java.util.stream.Stream
 
 Specified by:
 
 distinct in interface Traversable
 - sliding
```
default FutureStream<PVectorX> 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 FutureStream<PVectorX> 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
 - duplicateFutureStream
```
default org.jooq.lambda.tuple.Tuple2<FutureStream,FutureStream> duplicateFutureStream()
```
 - partition
```
default org.jooq.lambda.tuple.Tuple2<ReactiveSeq,ReactiveSeq> 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 FutureStream // tuple((1, 3, 5), (2, 4, 6)) FutureStream.of(1, 2, 3, 4, 5,6).partition(i -> i % 2 != 0)
 
 Specified by:
 
 partition in interface ReactiveSeq
 
 See Also:
 
 partitionFutureStream(Predicate), #partition(Stream, Predicate)
 - partitionFutureStream
```
default org.jooq.lambda.tuple.Tuple2<FutureStream,FutureStream> partitionFutureStream(java.util.function.Predicate<? super U> predicate)
```
 Partition an FutureStream into two LazyFutureStreams given a predicate.
```
 
 FutureStream.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:
 
 FutureStream
 
 See Also:
 
 partition(Predicate)
 - slice
```
default FutureStream slice(long from,
 long to)
```
 Specified by:
 
 slice in interface ReactiveSeq
 
 Specified by:
 
 slice in interface Traversable
 - zipWithIndex
```
default FutureStream<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)) FutureStream.of("a","b", "c").zipWithIndex()
 
 Specified by:
 
 zipWithIndex in interface ReactiveSeq
 
 Specified by:
 
 zipWithIndex in interface Traversable
 
 See Also:
 
 #zipWithIndex(Stream)
 - zipS
```
default <T> FutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> zipS(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:
 
 zipS in interface ReactiveSeq
 
 Specified by:
 
 zipS in interface Traversable
 
 Specified by:
 
 zipS in interface Zippable
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - zip
```
default <T> FutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> zip(java.lang.Iterable<? extends T> other)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
 
 Specified by:
 
 zip in interface ReactiveSeq
 
 Specified by:
 
 zip in interface Zippable
 
 Parameters:
 
 other - Iterable to combine with
 
 Returns:
 - zipS
```
default <T,R> FutureStream<R> zipS(java.util.stream.Stream<? extends T> other,
 java.util.function.BiFunction<? super U,? super T,? extends R> zipper)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
 
 Specified by:
 
 zipS in interface ReactiveSeq
 
 Specified by:
 
 zipS in interface Zippable
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zip
```
default <T,R> FutureStream<R> zip(java.lang.Iterable<? extends T> other,
 java.util.function.BiFunction<? super U,? super T,? extends R> zipper)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
 
 Specified by:
 
 zip in interface ReactiveSeq
 
 Specified by:
 
 zip in interface Traversable
 
 Specified by:
 
 zip in interface Zippable
 
 Parameters:
 
 other - to zip with
 
 zipper - Zip function
 
 Returns:
 
 Combined zippable
 - scanLeft
```
default <T> FutureStream<T> scanLeft(T seed,
 java.util.function.BiFunction<? super T,? super U,? extends T> function)
```
 Scan a stream to the left. // ("", "a", "ab", "abc") FutureStream.of("a", "b", "c").scanLeft("", (u, t) > u + t)
 
 Specified by:
 
 scanLeft in interface ReactiveSeq
 
 Specified by:
 
 scanLeft in interface Traversable
 - scanRight
```
default <R> FutureStream<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") FutureStream.of("a", "b", "c").scanRight("", (t, u) > u + t)
 
 Specified by:
 
 scanRight in interface ReactiveSeq
 
 Specified by:
 
 scanRight in interface Traversable
 - scanRight
```
default FutureStream 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 FutureStream reverse()
```
 Reverse a stream. - eager operation that materializes the Stream into a list - careful with infinite streams! // (3, 2, 1) FutureStream.of(1, 2, 3).reverse()
 
 Specified by:
 
 reverse in interface ReactiveSeq
 
 Specified by:
 
 reverse in interface Traversable
 - shuffle
```
default FutureStream shuffle()
```
 Shuffle a stream // e.g. (2, 3, 1) FutureStream.of(1, 2, 3).shuffle()
 
 Specified by:
 
 shuffle in interface ReactiveSeq
 
 Specified by:
 
 shuffle in interface Traversable
 - shuffle
```
default FutureStream shuffle(java.util.Random random)
```
 Shuffle a stream using specified source of randomness // e.g. (2, 3, 1) FutureStream.of(1, 2, 3).shuffle(new Random())
 
 Specified by:
 
 shuffle in interface ReactiveSeq
 
 Specified by:
 
 shuffle in interface Traversable
 - skipWhile
```
default FutureStream 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) FutureStream.of(1, 2, 3, 4, 5).skipWhile(i > i < 3)
 
 Specified by:
 
 skipWhile in interface ReactiveSeq
 
 Specified by:
 
 skipWhile in interface Traversable
 
 Parameters:
 
 predicate - Predicate to skip while true
 
 Returns:
 
 Stream with elements skipped while predicate holds
 
 See Also:
 
 #skipWhile(Stream, Predicate)
 - skipUntil
```
default FutureStream 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) FutureStream.of(1, 2, 3, 4, 5).skipUntil(i > i == 3)
 
 Specified by:
 
 skipUntil in interface ReactiveSeq
 
 Specified by:
 
 skipUntil in interface Traversable
 
 Parameters:
 
 predicate - Predicate to skip until true
 
 Returns:
 
 Stream with elements skipped until predicate holds
 
 See Also:
 
 #skipUntil(Stream, Predicate)
 - limitWhile
```
default FutureStream limitWhile(java.util.function.Predicate<? super U> predicate)
```
 Returns a stream limited to all elements for which a predicate evaluates to true. // (1, 2) FutureStream.of(1, 2, 3, 4, 5).limitWhile(i -> i < 3)
 
 Specified by:
 
 limitWhile in interface ReactiveSeq
 
 Specified by:
 
 limitWhile in interface Traversable
 
 Parameters:
 
 predicate - Limit while predicate is true
 
 Returns:
 
 Stream with limited elements
 
 See Also:
 
 #limitWhile(Stream, Predicate)
 - limitUntil
```
default FutureStream limitUntil(java.util.function.Predicate<? super U> predicate)
```
 Returns a stream limited to all elements for which a predicate evaluates to false. // (1, 2) FutureStream.of(1, 2, 3, 4, 5).limitUntil(i > i == 3)
 
 Specified by:
 
 limitUntil in interface ReactiveSeq
 
 Specified by:
 
 limitUntil in interface Traversable
 
 Parameters:
 
 predicate - Limit until predicate is true
 
 Returns:
 
 Stream with limited elements
 
 See Also:
 
 #limitUntil(Stream, Predicate)
 - crossJoin
```
default <T> FutureStream<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"))
 FutureStream.of(1, 2).crossJoin(FutureStream.of("a", "b"))
 
```
 - onEmpty
```
default FutureStream onEmpty(U value)
```
 Produce this stream, or an alternative stream from the value, in case this stream is empty.
```
 
 FutureStream.of().onEmpty(1)

 //1
 
```
 Specified by:
 
 onEmpty in interface OnEmpty
 
 Specified by:
 
 onEmpty in interface ReactiveSeq
 
 Specified by:
 
 onEmpty in interface Traversable
 
 Returns:
 
 New instance containing value if container is empty, otherwise returns this container
 - onEmptyGet
```
default FutureStream onEmptyGet(java.util.function.Supplier<? extends U> supplier)
```
 Produce this stream, or an alternative stream from the supplier, in case this stream is empty.
```
 
 FutureStream.of().onEmptyGet(() -> 1)


 //1
 
 
```
 Specified by:
 
 onEmptyGet in interface OnEmpty
 
 Specified by:
 
 onEmptyGet in interface ReactiveSeq
 
 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> FutureStream onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
 Produce this stream, or an alternative stream from the supplier, in case this stream is empty.
```
 
 FutureStream.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 Traversable
 
 Parameters:
 
 supplier - to create exception from
 
 Returns:
 
 Throw exception if empty, otherwise this container
 - innerJoin
```
default <T> FutureStream<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))
 FutureStream.of(1, 2, 3).innerJoin(Seq.of(1, 2), t -> Objects.equals(t.v1, t.v2))
 
```
 - leftOuterJoin
```
default <T> FutureStream<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))
 FutureStream.of(1, 2, 3).leftOuterJoin(Seq.of(1, 2), t -> Objects.equals(t.v1, t.v2))
 
```
 - rightOuterJoin
```
default <T> FutureStream<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))
 FutureStream.of(1, 2).rightOuterJoin(Seq.of(1, 2, 3), t -> Objects.equals(t.v1, t.v2))
 
```
 - cycle
```
default FutureStream cycle()
```
 Create a Stream that infinitely cycles this Stream
```
 
 assertThat(FutureStream.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
 
 Returns:
 
 New cycling stream
 - cycleWhile
```
default FutureStream cycleWhile(java.util.function.Predicate<? super U> predicate)
```
 Repeat in a Stream while specified predicate holds
```
 
 int count =0;

 assertThat(FutureStream.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 FutureStream cycleUntil(java.util.function.Predicate<? super U> predicate)
```
 Repeat in a Stream until specified predicate holds
```
 
 	count =0;
 assertThat(FutureStream.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
 - 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 FoldableTraversable
 
 Specified by:
 
 stream in interface ReactiveSeq
 
 Specified by:
 
 stream in interface Sequential
 
 Specified by:
 
 stream in interface ToStream
 
 Specified by:
 
 stream in interface TransformerTraversable
 
 Specified by:
 
 stream in interface Traversable
 
 Returns:
 
 This Traversable converted to a Stream
 - parallel
```
default FutureStream parallel()
```
 Specified by:
 
 parallel in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 parallel in interface ReactiveSeq
 
 Returns:
 
 Does nothing ReactiveSeq is for Sequential Streams
 - sequential
```
default FutureStream sequential()
```
 Specified by:
 
 sequential in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 sequential in interface ReactiveSeq
 - unordered
```
default FutureStream unordered()
```
 Specified by:
 
 unordered in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 unordered in interface ReactiveSeq
 - onClose
```
default FutureStream 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
 - sorted
```
default FutureStream 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 java.util.stream.Stream
 
 Specified by:
 
 sorted in interface Traversable
 - sorted
```
default FutureStream 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 java.util.stream.Stream
 
 Specified by:
 
 sorted in interface Traversable
 
 Parameters:
 
 comparator - Compartor to sort with
 
 Returns:
 
 Sorted Stream
 - self
```
default FutureStream self(java.util.function.Consumer<FutureStream> 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
```
static <T1> FutureStream<T1> flatten(ReactiveSeq<? extends java.util.stream.Stream<? extends T1>> nested)
```
 - narrow
```
static <T1> FutureStream<T1> narrow(FutureStream<? extends T1> broad)
```
 - toOptional
```
default java.util.Optional<ListX> toOptional()
```
 Specified by:
 
 toOptional in interface ConvertableSequence
 - toCompletableFuture
```
default java.util.concurrent.CompletableFuture<ListX> toCompletableFuture()
```
 - spliterator
```
default java.util.Spliterator spliterator()
```
 Description copied from interface: ReactiveSeq
 
 Returns a spliterator for the elements of this stream.
 
 This is a terminal operation.
 
 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 ReactiveSeq
 
 Returns:
 
 the element spliterator for this stream
 - 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 ReactiveSeq
 
 Specified by:
 
 mapToInt in interface java.util.stream.Stream
 
 Specified by:
 
 mapToInt in interface Traversable
 - mapToLong
```
default java.util.stream.LongStream mapToLong(java.util.function.ToLongFunction<? super U> mapper)
```
 Specified by:
 
 mapToLong in interface ReactiveSeq
 
 Specified by:
 
 mapToLong in interface java.util.stream.Stream
 
 Specified by:
 
 mapToLong in interface Traversable
 - mapToDouble
```
default java.util.stream.DoubleStream mapToDouble(java.util.function.ToDoubleFunction<? super U> mapper)
```
 Specified by:
 
 mapToDouble in interface ReactiveSeq
 
 Specified by:
 
 mapToDouble in interface java.util.stream.Stream
 
 Specified by:
 
 mapToDouble in interface Traversable
 - flatMapToInt
```
default java.util.stream.IntStream flatMapToInt(java.util.function.Function<? super U,? extends java.util.stream.IntStream> mapper)
```
 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 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 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 Folds
 
 Specified by:
 
 findAny in interface ReactiveSeq
 
 Specified by:
 
 findAny in interface java.util.stream.Stream
 
 Returns:
 first matching element, but order is not guaranteed
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findAny().get(); //3
 (non-deterministic)
 - toSet
```
default java.util.Set toSet()
```
 Specified by:
 
 toSet in interface CyclopsCollectable
 
 Specified by:
 
 toSet in interface ReactiveSeq
 
 Returns:
 
 This Stream converted to a set
 - toList
```
default java.util.List toList()
```
 Specified by:
 
 toList in interface CyclopsCollectable
 
 Specified by:
 
 toList in interface ReactiveSeq
 
 Returns:
 
 this Stream converted to a list
 - toCollection
```
default <C extends java.util.Collection> C toCollection(java.util.function.Supplier<C> collectionFactory)
```
 Specified by:
 
 toCollection in interface CyclopsCollectable
 
 Specified by:
 
 toCollection in interface ReactiveSeq
 - distinct
```
default <R> FutureStream distinct(java.util.function.Function<? super U,? extends R> keyExtractor)
```
 Specified by:
 
 distinct in interface ReactiveSeq
 - duplicate
```
default org.jooq.lambda.tuple.Tuple2<ReactiveSeq,ReactiveSeq> duplicate()
```
 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:
 
 duplicate 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
 - splitAtHead
```
default org.jooq.lambda.tuple.Tuple2<java.util.Optional,ReactiveSeq> splitAtHead()
```
 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:
 
 splitAtHead 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
 - cycle
```
default FutureStream cycle(Monoid m,
 long 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> FutureStream<org.jooq.lambda.tuple.Tuple3<U,S,R>> zip3(java.lang.Iterable<? extends S> second,
 java.lang.Iterable<? 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
 
 Specified by:
 
 zip3 in interface Zippable
 - zip4
```
default <T2,T3,T4> FutureStream<org.jooq.lambda.tuple.Tuple4<U,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
 java.lang.Iterable<? extends T3> third,
 java.lang.Iterable<? 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
 
 Specified by:
 
 zip4 in interface Zippable
 - grouped
```
default FutureStream<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 FutureStream 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 Folds
 
 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 Folds
 
 Specified by:
 
 startsWith in interface ReactiveSeq
 
 Parameters:
 
 iterator - Stream to check if this Folds has the same elements in the same order, at the skip
 
 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 Folds
 
 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 Folds
 
 Specified by:
 
 endsWith in interface ReactiveSeq
 
 Parameters:
 
 stream - Values to check
 
 Returns:
 
 true if ReactiveSeq endswith values in the supplied Stream
 - anyM
```
default AnyMSeq<Witness.reactiveSeq,U> anyM()
```
 Specified by:
 
 anyM in interface ReactiveSeq
 
 Returns:
 
 this ReactiveSeq converted to AnyM format
 - flatMapI
```
default <R> FutureStream<R> flatMapI(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:
 
 flatMapI in interface ReactiveSeq
 
 Returns:
 - flatMapP
```
default <R> FutureStream<R> flatMapP(java.util.function.Function<? super U,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
 Specified by:
 
 flatMapP in interface ReactiveSeq
 - flatMapStream
```
default <R> FutureStream<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 Folds
 
 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 Folds
 
 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 Folds
 
 Specified by:
 
 toConcurrentLazyStreamable in interface ReactiveSeq
 
 Returns:
 
 Streamable that replay this ReactiveSeq, populated lazily and can be populated across threads
 - append
```
default FutureStream append(U... values)
```
 Description copied from interface: ReactiveSeq
 Append values to the take 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 Traversable
 
 Parameters:
 
 values - to append
 
 Returns:
 
 ReactiveSeq with appended values
 - prepend
```
default FutureStream prepend(U... values)
```
 Description copied from interface: ReactiveSeq
 Prepend given values to the skip 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 Traversable
 
 Parameters:
 
 values - to prepend
 
 Returns:
 
 ReactiveSeq with values prepended
 - insertAt
```
default FutureStream 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
 
 Specified by:
 
 insertAt in interface Traversable
 
 Parameters:
 
 pos - to insert data at
 
 values - to insert
 
 Returns:
 
 Stream with new data inserted
 - deleteBetween
```
default FutureStream 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
 
 Specified by:
 
 deleteBetween in interface Traversable
 
 Parameters:
 
 start - index
 
 end - index
 
 Returns:
 
 Stream with elements removed
 - insertAtS
```
default FutureStream insertAtS(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).insertAtS(1, of(100, 200, 300)).map(it -> it + "!!").collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
 
 
```
 Specified by:
 
 insertAtS in interface ReactiveSeq
 
 Specified by:
 
 insertAtS in interface Traversable
 
 Parameters:
 
 pos - to insert Stream at
 
 stream - to insert
 
 Returns:
 
 newly conjoined ReactiveSeq
 - skip
```
default FutureStream 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 FutureStream 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 FutureStream 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 FutureStream 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 Folds
 
 Specified by:
 
 firstValue in interface ReactiveSeq
 
 Returns:
 
 first value in this Stream
 - groupedBySizeAndTime
```
default <C extends java.util.Collection<? super U>> FutureStream<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 FutureStream<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
 - groupedStatefullyUntil
```
default <C extends java.util.Collection,R> FutureStream<R> groupedStatefullyUntil(java.util.function.BiPredicate<C,? super U> predicate,
 java.util.function.Supplier<C> factory,
 java.util.function.Function<? super C,? extends R> finalizer)
```
 Specified by:
 
 groupedStatefullyUntil in interface ReactiveSeq
 - groupedStatefullyWhile
```
default FutureStream<ListX> groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super U>,? super U> predicate)
```
 Specified by:
 
 groupedStatefullyWhile in interface ReactiveSeq
 - groupedStatefullyWhile
```
default <C extends java.util.Collection,R> FutureStream<R> groupedStatefullyWhile(java.util.function.BiPredicate<C,? super U> predicate,
 java.util.function.Supplier<C> factory,
 java.util.function.Function<? super C,? extends R> finalizer)
```
 Specified by:
 
 groupedStatefullyWhile in interface ReactiveSeq
 - groupedUntil
```
default FutureStream<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, transform open next batch
 
 Returns:
 
 ReactiveSeq batched into lists determined by the predicate supplied
 - groupedWhile
```
default FutureStream<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, transform open next batch
 
 Returns:
 
 ReactiveSeq batched into lists determined by the predicate supplied
 - groupedWhile
```
default <C extends java.util.Collection<? super U>> FutureStream<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, transform 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>> FutureStream sorted(java.util.function.Function<? super U,? extends R> function)
```
 Specified by:
 
 sorted in interface ReactiveSeq
 
 Specified by:
 
 sorted in interface Traversable
 - groupedUntil
```
default <C extends java.util.Collection<? super U>> FutureStream<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, transform open next batch
 
 factory - Collection factory
 
 Returns:
 
 ReactiveSeq batched into collections determined by the predicate supplied
 - recover
```
default FutureStream recover(java.util.function.Function<? super 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
 
 Specified by:
 
 recover in interface Traversable
 
 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> FutureStream recover(java.lang.Class<EX> exceptionClass,
 java.util.function.Function<? super 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
 
 Specified by:
 
 recover in interface Traversable
 
 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
 - forEach
```
default <X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(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 = FutureStream.of(1,2,3,4)
 					 .forEach(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:
 
 forEach in interface FoldableTraversable
 
 Specified by:
 
 forEach 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.
 - forEach
```
default <X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(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 = FutureStream.of(()->1,()->2,()->{throw new RuntimeException()},()->4)
 .map(Supplier::get)
 					 .forEach(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:
 
 forEach in interface FoldableTraversable
 
 Specified by:
 
 forEach 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.
 - forEach
```
default <X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(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)
 					 .forEach(2,System.out::println, e->e.printStackTrace(),()->System.out.println("the take!"));
 
 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 take!
 
 
```
 Specified by:
 
 forEach in interface FoldableTraversable
 
 Specified by:
 
 forEach 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.
 - forEach
```
default <X extends java.lang.Throwable> void forEach(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 = FutureStream.of(()->1,()->2,()->{throw new RuntimeException()},()->4)
 .map(Supplier::get)
 					 .forEach(System.out::println, e->e.printStackTrace());
 
 System.out.println("processed!");
 
 
 
 //prints
 1
 2
 RuntimeException Stack Trace on System.err
 4
 processed!
 
 
 
```
 Specified by:
 
 forEach in interface FoldableTraversable
 
 Specified by:
 
 forEach in interface ReactiveStreamsTerminalOperations
 
 Parameters:
 
 consumerElement - To accept incoming elements from the Stream
 
 consumerError - To accept incoming processing errors from the Stream
 - forEach
```
default <X extends java.lang.Throwable> void forEach(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 = FutureStream.of(()->1,()->2,()->{throw new RuntimeException()},()->4)
 .map(Supplier::get)
 					 .forEachEvents(System.out::println, e->e.printStackTrace(),()->System.out.println("the take!"));
 
 System.out.println("processed!");
 
 
 //prints
 1
 2
 RuntimeException Stack Trace on System.err
 4 
 processed!
 
 
 
 
```
 Specified by:
 
 forEach in interface FoldableTraversable
 
 Specified by:
 
 forEach 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  FutureStream parallel(U... array)
```
 Construct an parallel FutureStream 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> FutureStream<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> FutureStream<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> FutureStream<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> FutureStream<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> FutureStream<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> FutureStream<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 java.util.stream.Stream
 
 Parameters:
 
 value - Value to construct ReactiveSeq from
 
 Returns:
 
 ReactiveSeq of one value
 - of
```
@SafeVarargs
static <T> FutureStream<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 java.util.stream.Stream
 
 Parameters:
 
 values - Value to construct ReactiveSeq from
 
 Returns:
 
 ReactiveSeq of one value
 - freeThread
```
static <T> FutureStream<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> FutureStream<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> FutureStream<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 java.util.stream.Stream
 - iterate
```
static <T> FutureStream<T> iterate(T seed,
 java.util.function.UnaryOperator<T> f)
```
 Specified by:
 
 iterate in interface ReactiveSeq
 
 Specified by:
 
 iterate in interface java.util.stream.Stream
 
 See Also:
 
 Stream.iterate(Object, UnaryOperator)
 - generate
```
static FutureStream<java.lang.Void> generate()
```
 Generate an infinite Stream of null values that runs on the current thread
 
 See Also:
 
 Stream.generate(Supplier)
 - generate
```
static <T> FutureStream<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 java.util.stream.Stream
 
 See Also:
 
 Stream.generate(Supplier)
 - generate
```
static <T> FutureStream<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 java.util.stream.Stream
 
 See Also:
 
 Stream.generate(Supplier)
 - lazyFutureStream
```
static <T> FutureStream<T> lazyFutureStream(java.util.stream.Stream<T> stream)
```
 Wrap a Stream into a FutureStream that runs on the current thread
 - lazyFutureStreamFromIterable
```
static <T> FutureStream<T> lazyFutureStreamFromIterable(java.lang.Iterable<T> iterable)
```
 Wrap an Iterable into a FutureStream that runs on the current thread
 - lazyFutureStream
```
static <T> FutureStream<T> lazyFutureStream(java.util.Iterator<T> iterator)
```
 Wrap an Iterator into a FutureStream that runs on the current thread

Interface FutureStream<U>

Nested Class Summary

Nested classes/interfaces inherited from interface cyclops.stream.ReactiveSeq

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

Nested classes/interfaces inherited from interface cyclops.function.Fn1

Method Summary

Methods inherited from interface com.aol.cyclops2.types.futurestream.LazySimpleReactStream

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

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

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

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

Methods inherited from interface cyclops.stream.ReactiveSeq

Methods inherited from interface com.aol.cyclops2.types.To

Methods inherited from interface java.util.stream.Stream

Methods inherited from interface java.util.stream.BaseStream

Methods inherited from interface com.aol.cyclops2.types.FoldableTraversable

Methods inherited from interface cyclops.function.Fn1

Methods inherited from interface org.jooq.lambda.function.Function1

Methods inherited from interface java.util.function.Function

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

Methods inherited from interface com.aol.cyclops2.types.Folds

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

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

Methods inherited from interface com.aol.cyclops2.types.stream.ToStream

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

Methods inherited from interface com.aol.cyclops2.hkt.Higher

Methods inherited from interface com.aol.cyclops2.hkt.Convert

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

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

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

Method Detail

builder

builder

foldFuture

futureOperations

futureOperations

collectSeq

fold

crossApply

outerApply

appendS

append

prependS

prepend

cycle

skipWhileClosed

limitWhileClosed

sorted

coflatMap

filterNot

notNull

trampoline

foldRight

zipP

elapsed

combine

onEmptySwitch

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

remove

subStream

permutations

combinations

actOnFutures

iterator

getSubscription

withLastActive

getSimpleReact

subscribe

chunkLastReadIterator

chunkSinceLastRead

count

withTaskExecutor

withRetrier

withLazyCollector

withQueueFactory