ReactiveSeqImpl (simple-react 1.0.0-RC4 API)

java.lang.Object
- com.aol.cyclops.internal.stream.ReactiveSeqImpl<T>

All Implemented Interfaces:

ReactiveSeq<T>, ZippingApplicativable<T>, ExtendedTraversable<T>, Filterable<T>, FilterableFunctor<T>, Foldable<T>, Functor<T>, IterableFilterable<T>, IterableFoldable<T>, IterableFunctor<T>, ConvertableSequence<T>, CyclopsCollectable<T>, JoolManipulation<T>, JoolWindowing<T>, ReactiveStreamsTerminalOperations<T>, TransformerTraversable<T>, Traversable<T>, Unit<T>, Unwrapable, java.lang.AutoCloseable, java.lang.Iterable<T>, java.util.stream.BaseStream<T,java.util.stream.Stream<T>>, java.util.stream.Stream<T>, org.jooq.lambda.Collectable<T>, org.jooq.lambda.Seq<T>, org.reactivestreams.Publisher<T>
```
public class ReactiveSeqImpl<T>
extends java.lang.Object
implements Unwrapable, ReactiveSeq<T>, java.lang.Iterable<T>
```

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

Constructor Summary

Constructors
Constructor and Description
`ReactiveSeqImpl(java.util.stream.Stream<T> stream)`
`ReactiveSeqImpl(java.util.stream.Stream<T> stream, ReversableSpliterator rev)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`boolean`	`allMatch(java.util.function.Predicate<? super T> c)` True if predicate matches all elements when Monad converted to a Stream
`AnyMSeq<T>`	`anyM()`
`boolean`	`anyMatch(java.util.function.Predicate<? super T> c)` True if a single element matches when Monad converted to a Stream
`ReactiveSeq<T>`	`append(T... values)` Append values to the end of this SequenceM
`ReactiveSeq<T>`	`append(T value)`
`ReactiveSeq<T>`	`appendStream(java.util.stream.Stream<T> stream)` Append Stream to this SequenceM
`<U> ReactiveSeq<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`void`	`close()`
`<R,A> R`	`collect(java.util.stream.Collector<? super T,A,R> collector)` Mutable reduction / collection over this Monad converted to a Stream
`<R> R`	`collect(java.util.function.Supplier<R> supplier, java.util.function.BiConsumer<R,? super T> accumulator, java.util.function.BiConsumer<R,R> combiner)`
`org.jooq.lambda.Collectable<T>`	`collectable()` Narrow this class to a Collectable
`ReactiveSeq<T>`	`concat(java.util.stream.Stream<? extends T> other)`
`ReactiveSeq<T>`	`concat(T... other)`
`ReactiveSeq<T>`	`concat(T other)`
`long`	`count()`
`ReactiveSeq<T>`	`cycle()` Convert to a Stream with the values infinitely cycled
`<R> ReactiveSeq<R>`	`cycle(java.lang.Class<R> monadC, int times)` Convert to a Stream, repeating the resulting structure specified times and lifting all values to the specified Monad type
`ReactiveSeq<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`ReactiveSeq<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`ReactiveSeq<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`ReactiveSeq<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`ReactiveSeq<T>`	`debounce(long time, java.util.concurrent.TimeUnit t)` Allow one element through per time period, drop all other elements in that time period
`ReactiveSeq<T>`	`deleteBetween(int start, int end)` Delete elements between given indexes in a Stream
`ReactiveSeq<T>`	`distinct()`
`<U> ReactiveSeq<T>`	`distinct(java.util.function.Function<? super T,? extends U> keyExtractor)`
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`duplicateSequence()` Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`boolean`	`endsWith(java.util.stream.Stream<T> iterable)` `assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Stream.of(5,6)));`
`boolean`	`endsWithIterable(java.lang.Iterable<T> iterable)` `assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Arrays.asList(5,6)));`
`ReactiveSeq<T>`	`filter(java.util.function.Predicate<? super T> fn)` Keep only elements for which the supplied predicates hold e.g.
`java.util.Optional<T>`	`findAny()`
`java.util.Optional<T>`	`findFirst()`
`T`	`firstValue()` `assertThat(ReactiveSeq.of(1,2,3,4) .map(u->{throw new RuntimeException();}) .recover(e->"hello") .firstValue(),equalTo("hello"));`
`ReactiveSeq<T>`	`fixedDelay(long l, java.util.concurrent.TimeUnit unit)` emit elements after a fixed delay
`<R> ReactiveSeq<R>`	`flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)` flatMap operation
`<R> ReactiveSeq<R>`	`flatMapAnyM(java.util.function.Function<? super T,AnyM<? extends R>> fn)` Allows flatMap return type to be any Monad type
`ReactiveSeq<java.lang.String>`	`flatMapBufferedReader(java.util.function.Function<? super T,java.io.BufferedReader> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied BufferedReaders
`ReactiveSeq<java.lang.Character>`	`flatMapCharSequence(java.util.function.Function<? super T,java.lang.CharSequence> fn)` Perform a flatMap operation where the result will be a flattened stream of Characters from the CharSequence returned by the supplied function.
`<R> ReactiveSeq<R>`	`flatMapCompletableFuture(java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)` flatMap to CompletableFuture - will block until Future complete, although (for non-blocking behaviour use AnyM wrapping CompletableFuture and flatMap to Stream there)
`ReactiveSeq<java.lang.String>`	`flatMapFile(java.util.function.Function<? super T,java.io.File> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied files.
`<R> ReactiveSeq<R>`	`flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)` Convenience method & performance optimisation flatMapping to a Stream will result in the Stream being converted to a List, if the host Monad type is not a Stream.
`<R> ReactiveSeq<R>`	`flatMapOptional(java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)` flatMap to optional - will result in null values being removed
`<R> ReactiveSeq<R>`	`flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)` flatMap operation
`java.util.stream.DoubleStream`	`flatMapToDouble(java.util.function.Function<? super T,? extends java.util.stream.DoubleStream> mapper)`
`java.util.stream.IntStream`	`flatMapToInt(java.util.function.Function<? super T,? extends java.util.stream.IntStream> mapper)`
`java.util.stream.LongStream`	`flatMapToLong(java.util.function.Function<? super T,? extends java.util.stream.LongStream> mapper)`
`ReactiveSeq<java.lang.String>`	`flatMapURL(java.util.function.Function<? super T,java.net.URL> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied URLs
`<T1> ReactiveSeq<T1>`	`flatten()` join / flatten one level of a nested hierarchy
`T`	`foldLeft(Monoid<T> reducer)`
`T`	`foldLeft(T identity, java.util.function.BinaryOperator<T> accumulator)` foldLeft : immutable reduction from left to right
`<T> T`	`foldLeftMapToType(Reducer<T> reducer)` Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
`T`	`foldRight(Monoid<T> reducer)` `ReactiveSeq.of("a","b","c").foldRight(Reducers.toString("")); // "cab"`
`T`	`foldRight(T identity, java.util.function.BinaryOperator<T> accumulator)` Immutable reduction from right to left
`<U> U`	`foldRight(U seed, java.util.function.BiFunction<? super T,? super U,? extends U> function)` Immutable reduction from right to left
`<T> T`	`foldRightMapToType(Reducer<T> reducer)` Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
`void`	`forEach(java.util.function.Consumer<? super T> action)`
`<R1,R> ReactiveSeq<R>`	`forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied stream
`<R1,R> ReactiveSeq<R>`	`forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied stream
`<R1,R2,R> ReactiveSeq<R>`	`forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`<R1,R2,R> ReactiveSeq<R>`	forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction) Perform a three level nested internal iteration over this Stream and the supplied streams
`<X extends java.lang.Throwable> void`	`forEachEvent(java.util.function.Consumer<? super T> 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.
`void`	`forEachOrdered(java.util.function.Consumer<? super T> action)`
`<X extends java.lang.Throwable> void`	`forEachWithError(java.util.function.Consumer<? super T> 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,
`<X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachX(long numberOfElements, java.util.function.Consumer<? super T> consumer)` Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time.
`<X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachXEvents(long numberOfElements, java.util.function.Consumer<? super T> 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.
`<X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachXWithError(long numberOfElements, java.util.function.Consumer<? super T> 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.
`java.lang.String`	`format()`
`FutureOperations<T>`	`futureOperations(java.util.concurrent.Executor exec)` Access asynchronous terminal operations (each returns a Future)
`<K> MapX<K,java.util.List<T>>`	`groupBy(java.util.function.Function<? super T,? extends K> classifier)` Use classifier function to group elements in this Sequence into a Map
`ReactiveSeq<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`<C extends java.util.Collection<? super T>> ReactiveSeq<C>`	`grouped(int size, java.util.function.Supplier<C> factory)` Batch elements in a Stream by size into a collection created by the supplied factory
`ReactiveSeq<ListX<T>>`	`groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit t)` Batch elements by size into a List
`<C extends java.util.Collection<? super T>> ReactiveSeq<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
`ReactiveSeq<ListX<T>>`	`groupedByTime(long time, java.util.concurrent.TimeUnit t)` Batch elements in a Stream by time period
`<C extends java.util.Collection<? super T>> ReactiveSeq<C>`	`groupedByTime(long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory)` Batch elements by time into a collection created by the supplied factory
`ReactiveSeq<ListX<T>>`	`groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)` Create ReactiveSeq of ListX where each ListX is populated while the supplied bipredicate holds.
`ReactiveSeq<ListX<T>>`	`groupedUntil(java.util.function.Predicate<? super T> predicate)` Create a ReactiveSeq batched by List, where each batch is populated until the predicate holds
`<C extends java.util.Collection<? super T>> ReactiveSeq<C>`	`groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
`ReactiveSeq<ListX<T>>`	`groupedWhile(java.util.function.Predicate<? super T> predicate)` Create a ReactiveSeq batched by List, where each batch is populated while the predicate holds
`<C extends java.util.Collection<? super T>> ReactiveSeq<C>`	`groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a ReactiveSeq batched by a Collection, where each batch is populated while the predicate holds
`HeadAndTail<T>`	`headAndTail()` extract head and tail together, where head is expected to be present
`HotStream<T>`	`hotStream(java.util.concurrent.Executor e)` Turns this ReactiveSeq into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data.
`ReactiveSeq<T>`	`insertAt(int pos, T... values)` Insert data into a stream at given position
`ReactiveSeq<T>`	`insertStreamAt(int pos, java.util.stream.Stream<T> stream)` Insert a Stream into the middle of this stream at the specified position
`ReactiveSeq<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`boolean`	`isParallel()`
`java.util.Iterator<T>`	`iterator()`
`ReactiveSeq<T>`	`jitter(long l)` Introduce a random jitter / time delay between the emission of elements
`java.lang.String`	`join()` `assertEquals("123".length(),of(1, 2, 3).join().length());`
`java.lang.String`	`join(java.lang.String sep)` `assertEquals("1, 2, 3".length(), of(1, 2, 3).join(", ").length());`
`java.lang.String`	`join(java.lang.String sep, java.lang.String start, java.lang.String end)` `assertEquals("^1\|2\|3$".length(), of(1, 2, 3).join("\|", "^", "$").length());`
`ReactiveSeq<T>`	`limit(long num)` `assertThat(anyM(Stream.of(4,3,6,7)).asSequence().limit(2).toList(),equalTo(Arrays.asList(4,3)));`
`ReactiveSeq<T>`	`limit(long time, java.util.concurrent.TimeUnit unit)` Return all elements until specified time period has elapsed
`ReactiveSeq<T>`	`limitLast(int num)` Limit results to the last x elements in a ReactiveSeq
`ReactiveSeq<T>`	`limitUntil(java.util.function.Predicate<? super T> p)` `assertThat(anyM(Stream.of(4,3,6,7)).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3)));`
`ReactiveSeq<T>`	`limitWhile(java.util.function.Predicate<? super T> p)` `assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));`
`<R> ReactiveSeq<R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> R`	`mapReduce(java.util.function.Function<? super T,? extends R> mapper, Monoid<R> reducer)` Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values
`<R> R`	`mapReduce(Reducer<R> reducer)` Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
`java.util.stream.DoubleStream`	`mapToDouble(java.util.function.ToDoubleFunction<? super T> mapper)`
`java.util.stream.IntStream`	`mapToInt(java.util.function.ToIntFunction<? super T> mapper)`
`java.util.stream.LongStream`	`mapToLong(java.util.function.ToLongFunction<? super T> mapper)`
`java.util.Optional<T>`	`max(java.util.Comparator<? super T> comparator)`
`<C extends java.lang.Comparable<? super C>> java.util.Optional<T>`	`maxBy(java.util.function.Function<? super T,? extends C> f)` Extract the maximum as determined by the supplied function
`java.util.Optional<T>`	`min(java.util.Comparator<? super T> comparator)`
`<U extends java.lang.Comparable<? super U>> java.util.Optional<T>`	`minBy(java.util.function.Function<? super T,? extends U> function)` Extract the minimum as determined by supplied function
`boolean`	`noneMatch(java.util.function.Predicate<? super T> c)`
`<U> ReactiveSeq<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`ReactiveSeq<T>`	`onClose(java.lang.Runnable closeHandler)`
`ReactiveSeq<T>`	`onEmpty(T value)`
`ReactiveSeq<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)`
`<X extends java.lang.Throwable> ReactiveSeq<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)`
`ReactiveSeq<T>`	`onePer(long time, java.util.concurrent.TimeUnit t)` emit one element per time period
`ReactiveSeq<T>`	`parallel()`
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`partitionSequence(java.util.function.Predicate<T> splitter)` Partition a Stream into two one a per element basis, based on predicate's boolean value
`PausableHotStream<T>`	`pausableHotStream(java.util.concurrent.Executor e)` Turns this ReactiveSeq into a HotStream, a connectable & pausable Stream, being executed on a thread on the supplied executor, that is producing data.
`ReactiveSeq<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Functor, without transforming it
`ReactiveSeq<T>`	`prepend(T... values)` Prepend given values to the start of the Stream
`ReactiveSeq<T>`	`prepend(T value)`
`ReactiveSeq<T>`	`prependStream(java.util.stream.Stream<T> stream)` Prepend Stream to this SequenceM
`HotStream<T>`	`primedHotStream(java.util.concurrent.Executor e)` Return a HotStream that will start emitting data when the first connecting Stream connects.
`PausableHotStream<T>`	`primedPausableHotStream(java.util.concurrent.Executor e)` Return a pausable HotStream that will start emitting data when the first connecting Stream connects.
`org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>`	`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.
`<EX extends java.lang.Throwable> ReactiveSeq<T>`	`recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<EX,? extends T> fn)` Recover from a particular exception type
`ReactiveSeq<T>`	`recover(java.util.function.Function<java.lang.Throwable,? extends T> fn)` Recover from an exception with an alternative value
`java.util.Optional<T>`	`reduce(java.util.function.BinaryOperator<T> accumulator)`
`ListX<T>`	`reduce(java.lang.Iterable<? extends Monoid<T>> reducers)` Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedStreamUtils.sequenceM() first.
`T`	`reduce(Monoid<T> reducer)` `ReactiveSeq.of("hello","2","world","4").reduce(Reducers.toString(",")); //hello,2,world,4`
`ListX<T>`	`reduce(java.util.stream.Stream<? extends Monoid<T>> reducers)` Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedStreamUtils.sequenceM() first.
`T`	`reduce(T identity, java.util.function.BinaryOperator<T> accumulator)`
`<U> U`	`reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator)`
`<U> U`	`reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner)`
`ReactiveSeq<T>`	`reverse()`
`ReactiveSeq<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> ReactiveSeq<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`ReactiveSeq<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> ReactiveSeq<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`HotStream<T>`	`schedule(java.lang.String cron, java.util.concurrent.ScheduledExecutorService ex)` Execute this Stream on a schedule
`HotStream<T>`	`scheduleFixedDelay(long delay, java.util.concurrent.ScheduledExecutorService ex)` Execute this Stream on a schedule
`HotStream<T>`	`scheduleFixedRate(long rate, java.util.concurrent.ScheduledExecutorService ex)` Execute this Stream on a schedule
`ReactiveSeq<T>`	`sequential()`
`ReactiveSeq<T>`	`shuffle()`
`ReactiveSeq<T>`	`shuffle(java.util.Random random)`
`ReactiveSeq<T>`	`skip(long num)` `assertThat(anyM(Stream.of(4,3,6,7)).asSequence().skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`ReactiveSeq<T>`	`skip(long time, java.util.concurrent.TimeUnit unit)` Skip all elements until specified time period has passed
`ReactiveSeq<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`ReactiveSeq<T>`	`skipUntil(java.util.function.Predicate<? super T> p)` `assertThat(anyM(Stream.of(4,3,6,7)).asSequence().skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));`
`ReactiveSeq<T>`	`skipWhile(java.util.function.Predicate<? super T> p)` `assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));`
`ReactiveSeq<T>`	`slice(long from, long to)`
`ReactiveSeq<ListX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`ReactiveSeq<ListX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`ReactiveSeq<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`ReactiveSeq<T>`	`sorted(java.util.Comparator<? super T> c)` `assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));`
`<U extends java.lang.Comparable<? super U>> ReactiveSeq<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`splitAt(int where)` Split at supplied location
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`splitBy(java.util.function.Predicate<T> splitter)` Split stream at point where predicate no longer holds
`java.util.Spliterator<T>`	`spliterator()`
`org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,ReactiveSeq<T>>`	`splitSequenceAtHead()` Split a Stream at it's head (similar to headAndTail)
`boolean`	`startsWith(java.util.stream.Stream<T> stream2)` `assertTrue(StreamUtils.sequenceM(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3).iterator()))`
`boolean`	`startsWithIterable(java.lang.Iterable<T> iterable)` `assertTrue(StreamUtils.sequenceM(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3)));`
`ReactiveSeq<T>`	`stream()` Unwrap this Monad into a Stream.
`void`	`subscribe(org.reactivestreams.Subscriber<? super T> sub)`
`java.lang.Object[]`	`toArray()`
`<A> A[]`	`toArray(java.util.function.IntFunction<A[]> generator)`
`<C extends java.util.Collection<T>> C`	`toCollection(java.util.function.Supplier<C> collectionFactory)`
`CollectionX<T>`	`toConcurrentLazyCollection()` Lazily converts this SequenceM into a Collection.
`Streamable<T>`	`toConcurrentLazyStreamable()` { @code Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6).map(i -> i + 2).toConcurrentLazyStreamable(); assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12))); assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12))); }
`CollectionX<T>`	`toLazyCollection()` Lazily converts this SequenceM into a Collection.
`Streamable<T>`	`toLazyStreamable()`
`java.util.List<T>`	`toList()`
`java.util.Set<T>`	`toSet()`
`<T> java.util.stream.Stream<T>`	`toStream()` Convert this ReactiveSeq into a Stream
`Streamable<T>`	`toStreamable()` `Streamable<Integer> repeat = ReactiveSeq.of(1,2,3,4,5,6) .map(i->i*2) .toStreamable(); repeat.sequenceM().toList(); //Arrays.asList(2,4,6,8,10,12)); repeat.sequenceM().toList() //Arrays.asList(2,4,6,8,10,12));`
`org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>`	`triplicate()` Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`<T> ReactiveSeq<T>`	`unit(T unit)`
`<T> ReactiveSeq<T>`	`unitIterator(java.util.Iterator<T> it)`
`ReactiveSeq<T>`	`unordered()`
`<R> R`	`unwrap()` Deprecated.
`java.util.stream.Stream<T>`	`unwrapStream()` Type safe unwrap
`boolean`	`xMatch(int num, java.util.function.Predicate<? super T> c)` Check that there are specified number of matches of predicate in the Stream
`ReactiveSeq<T>`	`xPer(int x, long time, java.util.concurrent.TimeUnit t)` emit x elements per time period
`<U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<? extends U> other)` Zip 2 streams into one
`<U,R> ReactiveSeq<R>`	`zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`<S> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,S>>`	`zip(java.util.stream.Stream<? extends S> second)` Zip 2 streams into one
`<S,U> ReactiveSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>>`	`zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends U> third)` zip 3 Streams into one
`<T2,T3,T4> ReactiveSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.util.stream.Stream<? extends T2> second, java.util.stream.Stream<? extends T3> third, java.util.stream.Stream<? extends T4> fourth)` zip 4 Streams into 1
`<S,R> ReactiveSeq<R>`	`zipStream(java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)` Zip this Monad with a Stream

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.aol.cyclops.control.ReactiveSeq
ap1, applicatives, avg, avg, avgDouble, avgInt, avgLong, combinations, combinations, combine, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, crossJoin, crossJoin, crossJoin, dropRight, dropUntil, dropWhile, elapsed, elementAt, empty, fromDoubleStream, fromIntStream, fromIterable, fromIterator, fromList, fromLongStream, fromPublisher, fromStream, generate, get, grouped, grouped, innerJoin, innerJoin, innerJoin, innerJoin, iterate, leftOuterJoin, leftOuterJoin, leftOuterJoin, leftOuterJoin, limitUntilClosed, max, max, max, maxBy, median, median, medianBy, medianBy, min, min, min, minBy, mode, of, onEmptySwitch, patternMatch, percentile, percentile, percentileBy, percentileBy, permutations, print, print, printErr, printOut, range, rangeLong, remove, retry, retry, reversedListOf, reversedOf, rightOuterJoin, rightOuterJoin, rightOuterJoin, single, single, singleOptional, size, skipUntilClosed, subscriber, subStream, sum, sum, sumDouble, sumInt, sumLong, takeRight, takeUntil, takeWhile, timestamp, toList, toMap, toSet, toString, toString, trampoline, unfold, unzip, unzip3, unzip4, zip, zip, zip, zipWithIndex

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

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

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

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

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

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

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

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

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

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

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

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

- Constructor Detail
 - ReactiveSeqImpl
```
public ReactiveSeqImpl(java.util.stream.Stream<T> stream)
```
 - ReactiveSeqImpl
```
public ReactiveSeqImpl(java.util.stream.Stream<T> stream,
 ReversableSpliterator rev)
```
- Method Detail
 - reduce
```
public  U reduce(U identity,
 java.util.function.BiFunction<U,? super T,U> accumulator)
```
 Specified by:
 
 reduce in interface Foldable<T>
 - unit
```
public <T> ReactiveSeq<T> unit(T unit)
```
 Specified by:
 
 unit in interface ReactiveSeq<T>
 
 Specified by:
 
 unit in interface Unit<T>
 - schedule
```
public HotStream<T> schedule(java.lang.String cron,
 java.util.concurrent.ScheduledExecutorService ex)
```
 Description copied from interface: ReactiveSeq
 Execute this Stream on a schedule
```
 
 //run at 8PM every night
 ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
 .map(this::processJob)
 .schedule("0 20 * * *",Executors.newScheduledThreadPool(1));
 
 
```
 Connect to the Scheduled Stream
```
 {
 @code
 HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
 .schedule("0 20 * * *", Executors.newScheduledThreadPool(1));
 
 data.connect().forEach(this::logToDB);
 }
 
```
 Specified by:
 
 schedule in interface ReactiveSeq<T>
 
 Specified by:
 
 schedule in interface Foldable<T>
 
 Parameters:
 
 cron - Expression that determines when each job will run
 
 ex - ScheduledExecutorService
 
 Returns:
 
 Connectable HotStream of output from scheduled Stream
 - scheduleFixedDelay
```
public HotStream<T> scheduleFixedDelay(long delay,
 java.util.concurrent.ScheduledExecutorService ex)
```
 Description copied from interface: ReactiveSeq
 Execute this Stream on a schedule
```
 
 //run every 60 seconds after last job completes
 ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
 .map(this::processJob)
 .scheduleFixedDelay(60_000,Executors.newScheduledThreadPool(1));
 
 
```
 Connect to the Scheduled Stream
```
 {
 @code
 HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
 .scheduleFixedDelay(60_000, Executors.newScheduledThreadPool(1));
 
 data.connect().forEach(this::logToDB);
 }
 
```
 Specified by:
 
 scheduleFixedDelay in interface ReactiveSeq<T>
 
 Specified by:
 
 scheduleFixedDelay in interface Foldable<T>
 
 Parameters:
 
 delay - Between last element completes passing through the Stream until the next one starts
 
 ex - ScheduledExecutorService
 
 Returns:
 
 Connectable HotStream of output from scheduled Stream
 - scheduleFixedRate
```
public HotStream<T> scheduleFixedRate(long rate,
 java.util.concurrent.ScheduledExecutorService ex)
```
 Description copied from interface: ReactiveSeq
 Execute this Stream on a schedule
```
 
 //run every 60 seconds
 ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
 .map(this::processJob)
 .scheduleFixedRate(60_000,Executors.newScheduledThreadPool(1));
 
 
```
 Connect to the Scheduled Stream
```
 {
 @code
 HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
 .scheduleFixedRate(60_000, Executors.newScheduledThreadPool(1));
 
 data.connect().forEach(this::logToDB);
 }
 
```
 Specified by:
 
 scheduleFixedRate in interface ReactiveSeq<T>
 
 Specified by:
 
 scheduleFixedRate in interface Foldable<T>
 
 Parameters:
 
 rate - Time in millis between job runs
 
 ex - ScheduledExecutorService
 
 Returns:
 
 Connectable HotStream of output from scheduled Stream
 - unwrap
```
@Deprecated
public final <R> R unwrap()
```
 Deprecated.
 
 Description copied from interface: Unwrapable
 
 Unwrap a wrapped value
 
 Specified by:
 
 unwrap in interface ReactiveSeq<T>
 
 Specified by:
 
 unwrap in interface Unwrapable
 
 Returns:
 
 wrapped value
 - flatten
```
public final <T1> ReactiveSeq<T1> flatten()
```
 join / flatten one level of a nested hierarchy
```
 
 assertThat(SequenceM.<Integer>of(Arrays.asList(1,2)).flatten().toList().size(),equalTo(asList(1, 2).size()));		
 
 // or more advanced example 
 
 AnyM<AnyM<Integer>> applied =anyM(Optional.of(2))
			 							.simpleFilter(anyM(Streamable.of( (Integer a)->a>5 ,(Integer a) -> a<3)));
	
	 assertThat(applied.toSequence().flatten().toList(),equalTo(Arrays.asList(2)));
 
 
 
 
```
 Specified by:
 
 flatten in interface ReactiveSeq<T>
 
 Returns:
 
 Flattened / joined one level
 - unwrapStream
```
public final java.util.stream.Stream<T> unwrapStream()
```
 Type safe unwrap
```
 
 Stream<String> stream = anyM("hello","world").asSequence().unwrapStream();
		assertThat(stream.collect(Collectors.toList()),equalTo(Arrays.asList("hello","world")));
 
 
```
 Returns:
 
 Stream with current wrapped values
 - cycle
```
public final ReactiveSeq<T> cycle(int times)
```
 Convert to a Stream with the values repeated specified times
```
 
 		assertThat(anyM(Stream.of(1,2,2)).asSequence()
											.cycle(3).collect(Collectors.toList()),
											equalTo(Arrays.asList(1,2,2,1,2,2,1,2,2)));
 
 
 
```
 Specified by:
 
 cycle in interface ReactiveSeq<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 times - Times values should be repeated within a Stream
 
 Returns:
 
 Stream with values repeated
 - cycle
```
public final ReactiveSeq<T> cycle()
```
 Convert to a Stream with the values infinitely cycled
```
 
 assertEquals(asList(1, 1, 1, 1, 1,1),of(1).cycle().limit(6).toList());
 
 
```
 Specified by:
 
 cycle in interface ReactiveSeq<T>
 
 Specified by:
 
 cycle in interface org.jooq.lambda.Seq<T>
 
 Returns:
 
 Stream with values repeated
 - duplicateSequence
```
public final org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> duplicateSequence()
```
 Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.
```
 
 Tuple2<ReactiveSeq<Integer>, ReactiveSeq<Integer>> copies =of(1,2,3,4,5,6).duplicate();
		 assertTrue(copies.v1.anyMatch(i->i==2));
		 assertTrue(copies.v2.anyMatch(i->i==2));
 
 
 
```
 Specified by:
 
 duplicateSequence in interface ReactiveSeq<T>
 
 Returns:
 
 duplicated stream
 - triplicate
```
public final org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> triplicate()
```
 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<T>
 - quadruplicate
```
public final org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> 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. 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<T>
 
 Returns:
 - splitSequenceAtHead
```
public final org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,ReactiveSeq<T>> splitSequenceAtHead()
```
 Split a Stream at it's head (similar to headAndTail)
```
 
 ReactiveSeq.of(1,2,3).splitAtHead()
 
 //Optional[1], SequenceM[2,3]
 
 
 
```
 Specified by:
 
 splitSequenceAtHead in interface ReactiveSeq<T>
 - splitAt
```
public final org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> splitAt(int where)
```
 Split at supplied location
```
 
 ReactiveSeq.of(1,2,3).splitAt(1)
 
 //SequenceM[1], SequenceM[2,3]
 
 
 
```
 Specified by:
 
 splitAt in interface ReactiveSeq<T>
 - splitBy
```
public final org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> splitBy(java.util.function.Predicate<T> splitter)
```
 Split stream at point where predicate no longer holds
```
 
 ReactiveSeq.of(1, 2, 3, 4, 5, 6).splitBy(i->i<4)
 
 //SequenceM[1,2,3] SequenceM[4,5,6]
 
 
```
 Specified by:
 
 splitBy in interface ReactiveSeq<T>
 - partitionSequence
```
public final org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> partitionSequence(java.util.function.Predicate<T> splitter)
```
 Partition a Stream into two one a per element basis, based on predicate's boolean value
```
 
 ReactiveSeq.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0) 
 
 //SequenceM[1,3,5], SequenceM[2,4,6]
 

 
```
 Specified by:
 
 partitionSequence in interface ReactiveSeq<T>
 - cycle
```
public final ReactiveSeq<T> cycle(Monoid<T> m,
 int times)
```
 Convert to a Stream with the result of a reduction operation repeated specified times
```
 
 		List<Integer> list = AsGenericMonad,asStreamUtils.sequenceM(Stream.of(1,2,2))
 										.cycle(Reducers.toCountInt(),3)
 										.collect(Collectors.toList());
 	//is asList(3,3,3);
 
 
```
 Specified by:
 
 cycle in interface ReactiveSeq<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 m - Monoid to be used in reduction
 
 times - Number of times value should be repeated
 
 Returns:
 
 Stream with reduced values repeated
 - cycle
```
public final <R> ReactiveSeq<R> cycle(java.lang.Class<R> monadC,
 int times)
```
 Convert to a Stream, repeating the resulting structure specified times and lifting all values to the specified Monad type
```
 {
 @code
 List<Optional<Integer>> list = StreamUtils.sequenceM(Stream.of(1, 2)).cycle(Optional.class,
 2).toList();
 
 // is asList(Optional.of(1),Optional.of(2),Optional.of(1),Optional.of(2) ));
 
 }
 
```
 Parameters:
 
 monadC - class type
 
 times -
 
 Returns:
 - cycleWhile
```
public final ReactiveSeq<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Repeat in a Stream while specified predicate holds
```
 
 count =0;
		assertThat(anyM(Stream.of(1,2,2)).asSequence()
											.cycleWhile(next -> count++<6)
											.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2)));
 
 
```
 Specified by:
 
 cycleWhile in interface ReactiveSeq<T>
 
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - cycleUntil
```
public final ReactiveSeq<T> cycleUntil(java.util.function.Predicate<? super T> predicate)
```
 Repeat in a Stream until specified predicate holds
```
 
 	count =0;
		assertThat(anyM(Stream.of(1,2,2)).asSequence()
											.cycleUntil(next -> count++>6)
											.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2,1)));
 
 
```
 Specified by:
 
 cycleUntil in interface ReactiveSeq<T>
 
 Specified by:
 
 cycleUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - zip
```
public final <S> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,S>> zip(java.util.stream.Stream<? extends S> second)
```
 Zip 2 streams into one
```
 
 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
 // [[1,"a"],[2,"b"]]
		 
 
```
 Specified by:
 
 zip in interface ReactiveSeq<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq<T>
 - zip3
```
public final <S,U> ReactiveSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second,
 java.util.stream.Stream<? extends U> third)
```
 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<T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 - zip4
```
public final <T2,T3,T4> ReactiveSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<? extends T2> second,
 java.util.stream.Stream<? extends T3> third,
 java.util.stream.Stream<? extends T4> fourth)
```
 zip 4 Streams into 1
```
 
 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<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 - zipStream
```
public final <S,R> ReactiveSeq<R> zipStream(java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second,
 java.util.function.BiFunction<? super T,? super S,? extends R> zipper)
```
 Zip this Monad with a Stream
```
 {
 @code
 Stream<List<Integer>> zipped = asStreamUtils.sequenceM(Stream.of(1, 2, 3)).zip(
 Stream.of(2, 3, 4), (a, b) -> Arrays.asList(a, b));
 
 // [[1,2][2,3][3,4]]
 }
 
```
 Specified by:
 
 zipStream in interface ReactiveSeq<T>
 
 Parameters:
 
 second - Stream to zip with
 
 zipper - Zip funciton
 
 Returns:
 
 This monad zipped with a Stream
 - sliding
```
public final ReactiveSeq<ListX<T>> sliding(int windowSize)
```
 Create a sliding view over this Sequence
```
 
 List<List<Integer>> list = anyM(Stream.of(1,2,3,4,5,6))
									.asSequence()
									.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<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - Size of sliding window
 
 Returns:
 
 SequenceM with sliding view
 - sliding
```
public final ReactiveSeq<ListX<T>> sliding(int windowSize,
 int increment)
```
 Create a sliding view over this Sequence
```
 
 List<List<Integer>> list = anyM(Stream.of(1,2,3,4,5,6))
									.asSequence()
									.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<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - number of elements in each batch
 
 increment - for each window
 
 Returns:
 
 SequenceM with sliding view
 - grouped
```
public final ReactiveSeq<ListX<T>> grouped(int groupSize)
```
 Group elements in a Stream
```
 {
 @code
 List<List<Integer>> list = StreamUtils.sequenceM(Stream.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<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - groupedStatefullyWhile
```
public ReactiveSeq<ListX<T>> groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
```
 Description copied from interface: ReactiveSeq
 Create ReactiveSeq of ListX where each ListX is populated while the supplied bipredicate holds. The bipredicate recieves the ListX from the last window as well as the current value and can choose to aggregate the current value or create a new window
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedStatefullyWhile((s,i)-> s.contains(4) ? true : false)
 .toList().size(),equalTo(5));
 
 
```
 Specified by:
 
 groupedStatefullyWhile in interface ReactiveSeq<T>
 
 Specified by:
 
 groupedStatefullyWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 ReactiveSeq windowed while predicate holds
 - groupBy
```
public final <K> MapX<K,java.util.List<T>> groupBy(java.util.function.Function<? super T,? extends K> classifier)
```
 Use classifier function to group elements in this Sequence into a Map
```
 
 Map<Integer, List<Integer>> map1 =of(1, 2, 3, 4).groupBy(i -> i % 2);
		 assertEquals(asList(2, 4), map1.get(0));
		 assertEquals(asList(1, 3), map1.get(1));
		 assertEquals(2, map1.size());
 
 
 
 
```
 Specified by:
 
 groupBy in interface ReactiveSeq<T>
 
 Specified by:
 
 groupBy in interface Foldable<T>
 
 Specified by:
 
 groupBy in interface org.jooq.lambda.Seq<T>
 - distinct
```
public final ReactiveSeq<T> distinct()
```
 Specified by:
 
 distinct in interface ReactiveSeq<T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 
 Specified by:
 
 distinct in interface java.util.stream.Stream<T>
 
 Specified by:
 
 distinct in interface org.jooq.lambda.Seq<T>
 - scanLeft
```
public final ReactiveSeq<T> scanLeft(Monoid<T> monoid)
```
 Scan left using supplied Monoid
```
 
 
 	assertEquals(asList("", "a", "ab", "abc"),StreamUtils.sequenceM(Stream.of("a", "b", "c")).scanLeft(Reducers.toString("")).toList());
 
 
 
```
 Specified by:
 
 scanLeft in interface ReactiveSeq<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Parameters:
 
 monoid -
 
 Returns:
 - scanLeft
```
public final  ReactiveSeq scanLeft(U seed,
 java.util.function.BiFunction<? super U,? super T,? extends U> function)
```
 Scan left
```
 
 assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
 		is(4));
 
 
```
 Specified by:
 
 scanLeft in interface ReactiveSeq<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Specified by:
 
 scanLeft in interface org.jooq.lambda.Seq<T>
 - scanRight
```
public final ReactiveSeq<T> scanRight(Monoid<T> monoid)
```
 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<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - scanRight
```
public final  ReactiveSeq scanRight(U identity,
 java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
```
 Scan right
```
 
 assertThat(of("a", "ab", "abc").map(str->str.length()).scanRight(0, (t, u) -> u + t).toList().size(),
 is(asList(0, 3, 5, 6).size()));
 
 
 
```
 Specified by:
 
 scanRight in interface ReactiveSeq<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 
 Specified by:
 
 scanRight in interface org.jooq.lambda.Seq<T>
 - sorted
```
public final ReactiveSeq<T> sorted()
```
```
 assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); 
 
```
 Specified by:
 
 sorted in interface ReactiveSeq<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Specified by:
 
 sorted in interface java.util.stream.Stream<T>
 
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq<T>
 - sorted
```
public final ReactiveSeq<T> sorted(java.util.Comparator<? super T> c)
```
```
 
 	assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
 
 
```
 Specified by:
 
 sorted in interface ReactiveSeq<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Specified by:
 
 sorted in interface java.util.stream.Stream<T>
 
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 c - Compartor to sort with
 
 Returns:
 
 Sorted Monad
 - skip
```
public final ReactiveSeq<T> skip(long num)
```
```
 assertThat(anyM(Stream.of(4,3,6,7)).asSequence().skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
 Specified by:
 
 skip in interface ReactiveSeq<T>
 
 Specified by:
 
 skip in interface Traversable<T>
 
 Specified by:
 
 skip in interface java.util.stream.Stream<T>
 
 Specified by:
 
 skip in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 num - Number of elemenets to skip
 
 Returns:
 
 Monad converted to Stream with specified number of elements skipped
 - skipWhile
```
public final ReactiveSeq<T> skipWhile(java.util.function.Predicate<? super T> p)
```
```
 
 assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
 
 
```
 Specified by:
 
 skipWhile in interface ReactiveSeq<T>
 
 Specified by:
 
 skipWhile in interface Traversable<T>
 
 Specified by:
 
 skipWhile in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 p - Predicate to skip while true
 
 Returns:
 
 Monad converted to Stream with elements skipped while predicate holds
 - skipUntil
```
public final ReactiveSeq<T> skipUntil(java.util.function.Predicate<? super T> p)
```
```
 assertThat(anyM(Stream.of(4,3,6,7)).asSequence().skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
 
```
 Specified by:
 
 skipUntil in interface ReactiveSeq<T>
 
 Specified by:
 
 skipUntil in interface Traversable<T>
 
 Specified by:
 
 skipUntil in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 p - Predicate to skip until true
 
 Returns:
 
 Monad converted to Stream with elements skipped until predicate holds
 - limit
```
public final ReactiveSeq<T> limit(long num)
```
```
 assertThat(anyM(Stream.of(4,3,6,7)).asSequence().limit(2).toList(),equalTo(Arrays.asList(4,3)));
 
```
 Specified by:
 
 limit in interface ReactiveSeq<T>
 
 Specified by:
 
 limit in interface Traversable<T>
 
 Specified by:
 
 limit in interface java.util.stream.Stream<T>
 
 Specified by:
 
 limit in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 num - Limit element size to num
 
 Returns:
 
 Monad converted to Stream with elements up to num
 - limitWhile
```
public final ReactiveSeq<T> limitWhile(java.util.function.Predicate<? super T> p)
```
```
 assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
 
```
 Specified by:
 
 limitWhile in interface ReactiveSeq<T>
 
 Specified by:
 
 limitWhile in interface Traversable<T>
 
 Specified by:
 
 limitWhile in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 p - Limit while predicate is true
 
 Returns:
 
 Monad converted to Stream with limited elements
 - limitUntil
```
public final ReactiveSeq<T> limitUntil(java.util.function.Predicate<? super T> p)
```
```
 assertThat(anyM(Stream.of(4,3,6,7)).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3))); 
 
```
 Specified by:
 
 limitUntil in interface ReactiveSeq<T>
 
 Specified by:
 
 limitUntil in interface Traversable<T>
 
 Specified by:
 
 limitUntil in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 p - Limit until predicate is true
 
 Returns:
 
 Monad converted to Stream with limited elements
 - parallel
```
public final ReactiveSeq<T> parallel()
```
 Specified by:
 
 parallel in interface ReactiveSeq<T>
 
 Specified by:
 
 parallel in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
 
 Specified by:
 
 parallel in interface org.jooq.lambda.Seq<T>
 
 Returns:
 
 does nothing - returns this
 - allMatch
```
public final boolean allMatch(java.util.function.Predicate<? super T> c)
```
 True if predicate matches all elements when Monad converted to a Stream
```
 
 assertThat(of(1,2,3,4,5).allMatch(it-> it>0 && it <6),equalTo(true));
 
 
```
 Specified by:
 
 allMatch in interface ReactiveSeq<T>
 
 Specified by:
 
 allMatch in interface CyclopsCollectable<T>
 
 Specified by:
 
 allMatch in interface java.util.stream.Stream<T>
 
 Specified by:
 
 allMatch in interface org.jooq.lambda.Collectable<T>
 
 Parameters:
 
 c - Predicate to check if all match
 - anyMatch
```
public final boolean anyMatch(java.util.function.Predicate<? super T> c)
```
 True if a single element matches when Monad converted to a Stream
```
 
 assertThat(of(1,2,3,4,5).anyMatch(it-> it.equals(3)),equalTo(true));
 
 
```
 Specified by:
 
 anyMatch in interface ReactiveSeq<T>
 
 Specified by:
 
 anyMatch in interface CyclopsCollectable<T>
 
 Specified by:
 
 anyMatch in interface java.util.stream.Stream<T>
 
 Specified by:
 
 anyMatch in interface org.jooq.lambda.Collectable<T>
 
 Parameters:
 
 c - Predicate to check if any match
 - xMatch
```
public boolean xMatch(int num,
 java.util.function.Predicate<? super T> c)
```
 Check that there are specified number of matches of predicate in the Stream
```
 
 assertTrue(ReactiveSeq.of(1,2,3,5,6,7).xMatch(3, i-> i>4 ));
 
 
```
 Specified by:
 
 xMatch in interface ReactiveSeq<T>
 
 Specified by:
 
 xMatch in interface Foldable<T>
 - noneMatch
```
public final boolean noneMatch(java.util.function.Predicate<? super T> c)
```
 Specified by:
 
 noneMatch in interface ReactiveSeq<T>
 
 Specified by:
 
 noneMatch in interface CyclopsCollectable<T>
 
 Specified by:
 
 noneMatch in interface java.util.stream.Stream<T>
 
 Specified by:
 
 noneMatch in interface org.jooq.lambda.Collectable<T>
 - join
```
public final java.lang.String join()
```
```
 
 assertEquals("123".length(),of(1, 2, 3).join().length());
 
 
```
 Specified by:
 
 join in interface ReactiveSeq<T>
 
 Specified by:
 
 join in interface Foldable<T>
 
 Specified by:
 
 join in interface org.jooq.lambda.Seq<T>
 
 Returns:
 
 Stream as concatenated String
 - join
```
public final java.lang.String join(java.lang.String sep)
```
```
 
 assertEquals("1, 2, 3".length(), of(1, 2, 3).join(", ").length());
 
 
```
 Specified by:
 
 join in interface ReactiveSeq<T>
 
 Specified by:
 
 join in interface Foldable<T>
 
 Returns:
 
 Stream as concatenated String
 - join
```
public final java.lang.String join(java.lang.String sep,
 java.lang.String start,
 java.lang.String end)
```
```
 
 assertEquals("^1|2|3$".length(), of(1, 2, 3).join("|", "^", "$").length());
 
 
```
 Specified by:
 
 join in interface ReactiveSeq<T>
 
 Specified by:
 
 join in interface Foldable<T>
 
 Returns:
 
 Stream as concatenated String
 - minBy
```
public final > java.util.Optional<T> minBy(java.util.function.Function<? super T,? extends U> function)
```
 Extract the minimum as determined by supplied function
 
 Specified by:
 
 minBy in interface ReactiveSeq<T>
 
 Specified by:
 
 minBy in interface CyclopsCollectable<T>
 
 Specified by:
 
 minBy in interface org.jooq.lambda.Collectable<T>
 - min
```
public final java.util.Optional<T> min(java.util.Comparator<? super T> comparator)
```
 Specified by:
 
 min in interface ReactiveSeq<T>
 
 Specified by:
 
 min in interface CyclopsCollectable<T>
 
 Specified by:
 
 min in interface java.util.stream.Stream<T>
 
 Specified by:
 
 min in interface org.jooq.lambda.Collectable<T>
 - maxBy
```
public final <C extends java.lang.Comparable<? super C>> java.util.Optional<T> maxBy(java.util.function.Function<? super T,? extends C> f)
```
 Extract the maximum as determined by the supplied function
 
 Specified by:
 
 maxBy in interface ReactiveSeq<T>
 
 Specified by:
 
 maxBy in interface CyclopsCollectable<T>
 
 Specified by:
 
 maxBy in interface org.jooq.lambda.Collectable<T>
 - max
```
public final java.util.Optional<T> max(java.util.Comparator<? super T> comparator)
```
 Specified by:
 
 max in interface ReactiveSeq<T>
 
 Specified by:
 
 max in interface CyclopsCollectable<T>
 
 Specified by:
 
 max in interface java.util.stream.Stream<T>
 
 Specified by:
 
 max in interface org.jooq.lambda.Collectable<T>
 - headAndTail
```
public final HeadAndTail<T> headAndTail()
```
 extract head and tail together, where head is expected to be present
```
 
 ReactiveSeq<String> helloWorld = ReactiveSeq.of("hello","world","last");
		HeadAndTail<String> headAndTail = helloWorld.headAndTail();
		 String head = headAndTail.head();
		 assertThat(head,equalTo("hello"));
		
		ReactiveSeq<String> tail = headAndTail.tail();
		assertThat(tail.headAndTail().head(),equalTo("world"));
 
 
```
 Specified by:
 
 headAndTail in interface ReactiveSeq<T>
 
 Specified by:
 
 headAndTail in interface IterableFoldable<T>
 
 Returns:
 - findFirst
```
public final java.util.Optional<T> findFirst()
```
 Specified by:
 
 findFirst in interface ReactiveSeq<T>
 
 Specified by:
 
 findFirst in interface Foldable<T>
 
 Specified by:
 
 findFirst in interface java.util.stream.Stream<T>
 
 Returns:
 
 First matching element in sequential order (deterministic)
 - findAny
```
public final java.util.Optional<T> findAny()
```
 Specified by:
 
 findAny in interface ReactiveSeq<T>
 
 Specified by:
 
 findAny in interface Foldable<T>
 
 Specified by:
 
 findAny in interface java.util.stream.Stream<T>
 
 Returns:
 
 first matching element, but order is not guaranteed (non-deterministic)
 - mapReduce
```
public final <R> R mapReduce(Reducer<R> reducer)
```
 Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
 
 Specified by:
 
 mapReduce in interface ReactiveSeq<T>
 
 Specified by:
 
 mapReduce in interface Foldable<T>
 
 Parameters:
 
 reducer - Monoid to reduce values
 
 Returns:
 
 Reduce result
 - mapReduce
```
public final <R> R mapReduce(java.util.function.Function<? super T,? extends R> mapper,
 Monoid<R> reducer)
```
 Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values
 
 Specified by:
 
 mapReduce in interface ReactiveSeq<T>
 
 Specified by:
 
 mapReduce in interface Foldable<T>
 
 Parameters:
 
 mapper - Function to map Monad type
 
 reducer - Monoid to reduce values
 
 Returns:
 
 Reduce result
 - collect
```
public final <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
```
 Mutable reduction / collection over this Monad converted to a Stream
 
 Specified by:
 
 collect in interface ReactiveSeq<T>
 
 Specified by:
 
 collect in interface CyclopsCollectable<T>
 
 Specified by:
 
 collect in interface java.util.stream.Stream<T>
 
 Specified by:
 
 collect in interface org.jooq.lambda.Collectable<T>
 
 Parameters:
 
 collector - Collection operation definition
 
 Returns:
 
 Collected result
 - collect
```
public final <R> R collect(java.util.function.Supplier<R> supplier,
 java.util.function.BiConsumer<R,? super T> accumulator,
 java.util.function.BiConsumer<R,R> combiner)
```
 Specified by:
 
 collect in interface java.util.stream.Stream<T>
 - reduce
```
public final T reduce(Monoid<T> reducer)
```
 Description copied from interface: ReactiveSeq
```
 
 ReactiveSeq.of("hello","2","world","4").reduce(Reducers.toString(","));
 
 //hello,2,world,4
 
 
```
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Specified by:
 
 reduce in interface Foldable<T>
 
 Parameters:
 
 reducer - Use supplied Monoid to reduce values
 
 Returns:
 
 reduced values
 - reduce
```
public final java.util.Optional<T> reduce(java.util.function.BinaryOperator<T> accumulator)
```
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Specified by:
 
 reduce in interface Foldable<T>
 
 Specified by:
 
 reduce in interface java.util.stream.Stream<T>
 - reduce
```
public final T reduce(T identity,
 java.util.function.BinaryOperator<T> accumulator)
```
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Specified by:
 
 reduce in interface Foldable<T>
 
 Specified by:
 
 reduce in interface java.util.stream.Stream<T>
 - reduce
```
public final  U reduce(U identity,
 java.util.function.BiFunction<U,? super T,U> accumulator,
 java.util.function.BinaryOperator combiner)
```
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Specified by:
 
 reduce in interface Foldable<T>
 
 Specified by:
 
 reduce in interface java.util.stream.Stream<T>
 - reduce
```
public final ListX<T> reduce(java.util.stream.Stream<? extends Monoid<T>> reducers)
```
 Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedStreamUtils.sequenceM() first. I.e. streamedStreamUtils.sequenceM().reduce(reducer)
 
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Specified by:
 
 reduce in interface Foldable<T>
 
 Parameters:
 
 reducers -
 
 Returns:
 - reduce
```
public final ListX<T> reduce(java.lang.Iterable<? extends Monoid<T>> reducers)
```
 Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedStreamUtils.sequenceM() first. I.e. streamedStreamUtils.sequenceM().reduce(reducer)
 
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Specified by:
 
 reduce in interface Foldable<T>
 
 Parameters:
 
 reducers -
 
 Returns:
 - foldLeft
```
public final T foldLeft(Monoid<T> reducer)
```
 Parameters:
 
 reducer - Use supplied Monoid to reduce values starting via foldLeft
 
 Returns:
 
 Reduced result
 - foldLeft
```
public final T foldLeft(T identity,
 java.util.function.BinaryOperator<T> accumulator)
```
 foldLeft : immutable reduction from left to right
```
 
 
 assertTrue(ReactiveSeq.of("a", "b", "c").foldLeft("", String::concat).equals("abc"));
 
 
```
 - foldLeftMapToType
```
public final <T> T foldLeftMapToType(Reducer<T> reducer)
```
 Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
 
 Parameters:
 
 reducer - Monoid to reduce values
 
 Returns:
 
 Reduce result
 - foldRight
```
public final T foldRight(Monoid<T> reducer)
```
 Description copied from interface: ReactiveSeq
```
 
 		ReactiveSeq.of("a","b","c").foldRight(Reducers.toString(""));
 
 // "cab"
 
 
```
 Specified by:
 
 foldRight in interface ReactiveSeq<T>
 
 Specified by:
 
 foldRight in interface Foldable<T>
 
 Parameters:
 
 reducer - Use supplied Monoid to reduce values starting via foldRight
 
 Returns:
 
 Reduced result
 - foldRight
```
public final  U foldRight(U seed,
 java.util.function.BiFunction<? super T,? super U,? extends U> function)
```
 Immutable reduction from right to left
```
 
 assertTrue(ReactiveSeq.of("a","b","c").foldRight("", String::concat).equals("cba"));
 
 
```
 Specified by:
 
 foldRight in interface ReactiveSeq<T>
 
 Specified by:
 
 foldRight in interface Foldable<T>
 
 Specified by:
 
 foldRight in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 identity -
 
 accumulator -
 
 Returns:
 - foldRightMapToType
```
public final <T> T foldRightMapToType(Reducer<T> reducer)
```
 Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
 
 Specified by:
 
 foldRightMapToType in interface ReactiveSeq<T>
 
 Specified by:
 
 foldRightMapToType in interface Foldable<T>
 
 Parameters:
 
 reducer - Monoid to reduce values
 
 Returns:
 
 Reduce result
 - toStreamable
```
public final Streamable<T> toStreamable()
```
 Description copied from interface: ReactiveSeq
```
 
 	Streamable<Integer> repeat = ReactiveSeq.of(1,2,3,4,5,6)
 												.map(i->i*2)
 												.toStreamable();
 		
 		repeat.sequenceM().toList(); //Arrays.asList(2,4,6,8,10,12));
 		repeat.sequenceM().toList() //Arrays.asList(2,4,6,8,10,12));
 
 
```
 Specified by:
 
 toStreamable in interface ReactiveSeq<T>
 
 Specified by:
 
 toStreamable in interface ConvertableSequence<T>
 
 Returns:
 
 Underlying Stream (lazily) converted to a Streamable instance
 - toSet
```
public final java.util.Set<T> toSet()
```
 Specified by:
 
 toSet in interface ReactiveSeq<T>
 
 Specified by:
 
 toSet in interface CyclopsCollectable<T>
 
 Specified by:
 
 toSet in interface org.jooq.lambda.Collectable<T>
 
 Returns:
 
 This monad converted to a set
 - toList
```
public final java.util.List<T> toList()
```
 Specified by:
 
 toList in interface ReactiveSeq<T>
 
 Specified by:
 
 toList in interface CyclopsCollectable<T>
 
 Specified by:
 
 toList in interface org.jooq.lambda.Collectable<T>
 
 Returns:
 
 this monad converted to a list
 - toCollection
```
public final <C extends java.util.Collection<T>> C toCollection(java.util.function.Supplier<C> collectionFactory)
```
 Specified by:
 
 toCollection in interface ReactiveSeq<T>
 
 Specified by:
 
 toCollection in interface CyclopsCollectable<T>
 
 Specified by:
 
 toCollection in interface org.jooq.lambda.Collectable<T>
 - toStream
```
public final <T> java.util.stream.Stream<T> toStream()
```
 Description copied from interface: ReactiveSeq
 
 Convert this ReactiveSeq into a Stream
 
 Specified by:
 
 toStream in interface ReactiveSeq<T>
 
 Returns:
 
 calls to stream() but more flexible on type for inferencing purposes.
 - stream
```
public final ReactiveSeq<T> stream()
```
 Unwrap this Monad into a Stream. If the underlying monad is a Stream it is returned Otherwise we flatMap the underlying monad to a Stream type
 
 Specified by:
 
 stream in interface ReactiveSeq<T>
 
 Specified by:
 
 stream in interface ExtendedTraversable<T>
 
 Specified by:
 
 stream in interface Foldable<T>
 
 Specified by:
 
 stream in interface IterableFunctor<T>
 
 Specified by:
 
 stream in interface ConvertableSequence<T>
 
 Specified by:
 
 stream in interface TransformerTraversable<T>
 
 Specified by:
 
 stream in interface Traversable<T>
 
 Specified by:
 
 stream in interface org.jooq.lambda.Seq<T>
 - startsWithIterable
```
public final boolean startsWithIterable(java.lang.Iterable<T> iterable)
```
```
 
 assertTrue(StreamUtils.sequenceM(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3)));
 
```
 Specified by:
 
 startsWithIterable in interface ReactiveSeq<T>
 
 Specified by:
 
 startsWithIterable in interface Foldable<T>
 
 Parameters:
 
 iterable -
 
 Returns:
 
 True if Monad starts with Iterable sequence of data
 - startsWith
```
public final boolean startsWith(java.util.stream.Stream<T> stream2)
```
```
 assertTrue(StreamUtils.sequenceM(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3).iterator())) 
```
 Specified by:
 
 startsWith in interface ReactiveSeq<T>
 
 Specified by:
 
 startsWith in interface Foldable<T>
 
 Parameters:
 
 iterator -
 
 Returns:
 
 True if Monad starts with Iterators sequence of data
 - anyM
```
public AnyMSeq<T> anyM()
```
 Specified by:
 
 anyM in interface ReactiveSeq<T>
 
 Returns:
 
 this SequenceM converted to AnyM format
 - map
```
public final <R> ReactiveSeq<R> map(java.util.function.Function<? super T,? extends R> fn)
```
 Description copied from interface: Functor
 Transform this functor using the supplied transformation function
```
 
 
 
 of(1,2,3).map(i->i*2)
 
 //[2,4,6]
 
 
 
```
 Specified by:
 
 map in interface ReactiveSeq<T>
 
 Specified by:
 
 map in interface FilterableFunctor<T>
 
 Specified by:
 
 map in interface Functor<T>
 
 Specified by:
 
 map in interface IterableFunctor<T>
 
 Specified by:
 
 map in interface java.util.stream.Stream<T>
 
 Specified by:
 
 map in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 fn - Transformation function
 
 Returns:
 
 Transformed Functor
 - peek
```
public final ReactiveSeq<T> peek(java.util.function.Consumer<? super T> c)
```
 Description copied from interface: Functor
 Peek at the current value of this Functor, without transforming it
```
 
 
 
 of(1,2,3).map(System.out::println)
 
 1
 2
 3
 
 
 
```
 Specified by:
 
 peek in interface ReactiveSeq<T>
 
 Specified by:
 
 peek in interface Functor<T>
 
 Specified by:
 
 peek in interface java.util.stream.Stream<T>
 
 Specified by:
 
 peek in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 c - Consumer that recieves each element from this Functor
 
 Returns:
 
 Functor that will peek at each value
 - flatMap
```
public final <R> ReactiveSeq<R> flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)
```
 flatMap operation
```
 
 	assertThat(this.<Integer>of(1,2).flatMap(i -> asList(i, -i).stream()).toList(),equalTo(asList(1, -1, 2, -2)));		
 
 
 
```
 Specified by:
 
 flatMap in interface ReactiveSeq<T>
 
 Specified by:
 
 flatMap in interface java.util.stream.Stream<T>
 
 Specified by:
 
 flatMap in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 fn - to be applied
 
 Returns:
 
 new stage in Sequence with flatMap operation to be lazily applied
 - flatMapAnyM
```
public final <R> ReactiveSeq<R> flatMapAnyM(java.util.function.Function<? super T,AnyM<? extends R>> fn)
```
 Allows flatMap return type to be any Monad type
```
 
 	assertThat(anyM(Seq.of(1,2,3)).asSequence().flatMapAnyM(i-> anyM(CompletableFuture.completedFuture(i+2))).toList(),equalTo(Arrays.asList(3,4,5)));
 
```
 Specified by:
 
 flatMapAnyM in interface ReactiveSeq<T>
 
 Parameters:
 
 fn - to be applied
 
 Returns:
 
 new stage in Sequence with flatMap operation to be lazily applied
 - flatMapIterable
```
public final <R> ReactiveSeq<R> flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)
```
 Convenience method & performance optimisation flatMapping to a Stream will result in the Stream being converted to a List, if the host Monad type is not a Stream. (i.e.
```
 
 AnyM<Integer> opt = anyM(Optional.of(20));
 Optional<List<Integer>> optionalList = opt.flatMap( i -> anyM(Stream.of(1,2,i))).unwrap(); 
 
 //Optional [1,2,20]
 
```
 In such cases using Arrays.asList would be more performant
```
 
 AnyM<Integer> opt = anyM(Optional.of(20));
 Optional<List<Integer>> optionalList = opt.flatMapCollection( i -> asList(1,2,i))).unwrap(); 
 
 //Optional [1,2,20]
 
```
 Specified by:
 
 flatMapIterable in interface ReactiveSeq<T>
 
 Parameters:
 
 fn -
 
 Returns:
 - flatMapStream
```
public final <R> ReactiveSeq<R> flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)
```
 flatMap operation
```
 
 	assertThat(anyM(Stream.of(1,2,3)).asSequence().flatMapStream(i->Stream.of(i)).toList(),equalTo(Arrays.asList(1,2,3)));
 
 
```
 Specified by:
 
 flatMapStream in interface ReactiveSeq<T>
 
 Parameters:
 
 fn - to be applied
 
 Returns:
 
 new stage in Sequence with flatMap operation to be lazily applied
 - flatMapOptional
```
public final <R> ReactiveSeq<R> flatMapOptional(java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)
```
 flatMap to optional - will result in null values being removed
```
 
 	assertThat(ReactiveSeq.of(1,2,3,null).flatMapOptional(Optional::ofNullable)
			 										.collect(Collectors.toList()),
			 										equalTo(Arrays.asList(1,2,3)));
 
 
```
 Parameters:
 
 fn -
 
 Returns:
 - flatMapCompletableFuture
```
public final <R> ReactiveSeq<R> flatMapCompletableFuture(java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)
```
 flatMap to CompletableFuture - will block until Future complete, although (for non-blocking behaviour use AnyM wrapping CompletableFuture and flatMap to Stream there)
```
 
 	assertThat(ReactiveSeq.of(1,2,3).flatMapCompletableFuture(i->CompletableFuture.completedFuture(i+2))
				 								.collect(Collectors.toList()),
				 								equalTo(Arrays.asList(3,4,5)));
 
 
```
 Parameters:
 
 fn -
 
 Returns:
 - flatMapCharSequence
```
public final ReactiveSeq<java.lang.Character> flatMapCharSequence(java.util.function.Function<? super T,java.lang.CharSequence> fn)
```
 Perform a flatMap operation where the result will be a flattened stream of Characters from the CharSequence returned by the supplied function.
```
 
 List<Character> result = anyM("input.file")
									.asSequence()
									.flatMapCharSequence(i->"hello world")
									.toList();
		
		assertThat(result,equalTo(Arrays.asList('h','e','l','l','o',' ','w','o','r','l','d')));
 
 
```
 Parameters:
 
 fn -
 
 Returns:
 - flatMapFile
```
public final ReactiveSeq<java.lang.String> flatMapFile(java.util.function.Function<? super T,java.io.File> fn)
```
 Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied files.
```
 
 
		List<String> result = anyM("input.file")
								.asSequence()
								.map(getClass().getClassLoader()::getResource)
								.peek(System.out::println)
								.map(URL::getFile)
								.liftAndBindFile(File::new)
								.toList();
		
		assertThat(result,equalTo(Arrays.asList("hello","world")));
 
 
 
 
```
 Parameters:
 
 fn -
 
 Returns:
 - flatMapURL
```
public final ReactiveSeq<java.lang.String> flatMapURL(java.util.function.Function<? super T,java.net.URL> fn)
```
 Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied URLs
```
 
 List<String> result = anyM("input.file")
								.asSequence()
								.liftAndBindURL(getClass().getClassLoader()::getResource)
								.toList();
		
		assertThat(result,equalTo(Arrays.asList("hello","world")));
 
 
 
```
 Parameters:
 
 fn -
 
 Returns:
 - flatMapBufferedReader
```
public final ReactiveSeq<java.lang.String> flatMapBufferedReader(java.util.function.Function<? super T,java.io.BufferedReader> fn)
```
 Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied BufferedReaders
```
 List result = anyM("input.file")
 .asSequence()
 .map(getClass().getClassLoader()::getResourceAsStream)
 .map(InputStreamReader::new)
 .liftAndBindBufferedReader(BufferedReader::new)
 .toList();
 
 assertThat(result,equalTo(Arrays.asList("hello","world")));
 
 
```
 Parameters:
 
 fn -
 
 Returns:
 - filter
```
public final ReactiveSeq<T> filter(java.util.function.Predicate<? super T> fn)
```
 Description copied from interface: Filterable
 Keep only elements for which the supplied predicates hold e.g.
```
 
 
 of(1,2,3).filter(i->i>2);
 
 //[3]
 
 
 
```
 Specified by:
 
 filter in interface ReactiveSeq<T>
 
 Specified by:
 
 filter in interface Filterable<T>
 
 Specified by:
 
 filter in interface FilterableFunctor<T>
 
 Specified by:
 
 filter in interface JoolManipulation<T>
 
 Specified by:
 
 filter in interface java.util.stream.Stream<T>
 
 Specified by:
 
 filter in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - forEach
```
public void forEach(java.util.function.Consumer<? super T> action)
```
 Specified by:
 
 forEach in interface java.lang.Iterable<T>
 
 Specified by:
 
 forEach in interface java.util.stream.Stream<T>
 
 Specified by:
 
 forEach in interface org.jooq.lambda.Seq<T>
 - iterator
```
public java.util.Iterator<T> iterator()
```
 Specified by:
 
 iterator in interface java.lang.Iterable<T>
 
 Specified by:
 
 iterator in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
 - spliterator
```
public java.util.Spliterator<T> spliterator()
```
 Specified by:
 
 spliterator in interface java.lang.Iterable<T>
 
 Specified by:
 
 spliterator in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
 
 Specified by:
 
 spliterator in interface org.jooq.lambda.Seq<T>
 - isParallel
```
public boolean isParallel()
```
 Specified by:
 
 isParallel in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
 - sequential
```
public ReactiveSeq<T> sequential()
```
 Specified by:
 
 sequential in interface ReactiveSeq<T>
 
 Specified by:
 
 sequential in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
 
 Specified by:
 
 sequential in interface org.jooq.lambda.Seq<T>
 - unordered
```
public ReactiveSeq<T> unordered()
```
 Specified by:
 
 unordered in interface ReactiveSeq<T>
 
 Specified by:
 
 unordered in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
 
 Specified by:
 
 unordered in interface org.jooq.lambda.Seq<T>
 - mapToInt
```
public java.util.stream.IntStream mapToInt(java.util.function.ToIntFunction<? super T> mapper)
```
 Specified by:
 
 mapToInt in interface java.util.stream.Stream<T>
 
 Specified by:
 
 mapToInt in interface org.jooq.lambda.Seq<T>
 - mapToLong
```
public java.util.stream.LongStream mapToLong(java.util.function.ToLongFunction<? super T> mapper)
```
 Specified by:
 
 mapToLong in interface java.util.stream.Stream<T>
 
 Specified by:
 
 mapToLong in interface org.jooq.lambda.Seq<T>
 - mapToDouble
```
public java.util.stream.DoubleStream mapToDouble(java.util.function.ToDoubleFunction<? super T> mapper)
```
 Specified by:
 
 mapToDouble in interface java.util.stream.Stream<T>
 
 Specified by:
 
 mapToDouble in interface org.jooq.lambda.Seq<T>
 - flatMapToInt
```
public java.util.stream.IntStream flatMapToInt(java.util.function.Function<? super T,? extends java.util.stream.IntStream> mapper)
```
 Specified by:
 
 flatMapToInt in interface java.util.stream.Stream<T>
 
 Specified by:
 
 flatMapToInt in interface org.jooq.lambda.Seq<T>
 - flatMapToLong
```
public java.util.stream.LongStream flatMapToLong(java.util.function.Function<? super T,? extends java.util.stream.LongStream> mapper)
```
 Specified by:
 
 flatMapToLong in interface java.util.stream.Stream<T>
 
 Specified by:
 
 flatMapToLong in interface org.jooq.lambda.Seq<T>
 - flatMapToDouble
```
public java.util.stream.DoubleStream flatMapToDouble(java.util.function.Function<? super T,? extends java.util.stream.DoubleStream> mapper)
```
 Specified by:
 
 flatMapToDouble in interface java.util.stream.Stream<T>
 
 Specified by:
 
 flatMapToDouble in interface org.jooq.lambda.Seq<T>
 - forEachOrdered
```
public void forEachOrdered(java.util.function.Consumer<? super T> action)
```
 Specified by:
 
 forEachOrdered in interface java.util.stream.Stream<T>
 - toArray
```
public java.lang.Object[] toArray()
```
 Specified by:
 
 toArray in interface java.util.stream.Stream<T>
 - toArray
```
public <A> A[] toArray(java.util.function.IntFunction<A[]> generator)
```
 Specified by:
 
 toArray in interface java.util.stream.Stream<T>
 - count
```
public long count()
```
 Specified by:
 
 count in interface ReactiveSeq<T>
 
 Specified by:
 
 count in interface CyclopsCollectable<T>
 
 Specified by:
 
 count in interface java.util.stream.Stream<T>
 
 Specified by:
 
 count in interface org.jooq.lambda.Collectable<T>
 
 Specified by:
 
 count in interface org.jooq.lambda.Seq<T>
 - intersperse
```
public ReactiveSeq<T> intersperse(T value)
```
 Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) ReactiveSeq.of(1, 2, 3, 4).intersperse(0)
 
 Specified by:
 
 intersperse in interface ReactiveSeq<T>
 
 Specified by:
 
 intersperse in interface Traversable<T>
 
 Specified by:
 
 intersperse in interface org.jooq.lambda.Seq<T>
 - ofType
```
public  ReactiveSeq ofType(java.lang.Class<? extends U> type)
```
 Keep only those elements in a stream that are of a given type. // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
 
 Specified by:
 
 ofType in interface ReactiveSeq<T>
 
 Specified by:
 
 ofType in interface Filterable<T>
 
 Specified by:
 
 ofType in interface JoolManipulation<T>
 
 Specified by:
 
 ofType in interface org.jooq.lambda.Seq<T>
 - cast
```
public  ReactiveSeq cast(java.lang.Class<? extends U> type)
```
 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 ReactiveSeq<T>
 
 Specified by:
 
 cast in interface Functor<T>
 
 Specified by:
 
 cast in interface org.jooq.lambda.Seq<T>
 - toLazyCollection
```
public CollectionX<T> toLazyCollection()
```
 Lazily converts this SequenceM 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();
		System.out.println("first!");
		col.forEach(System.out::println);
 
 
 //Will print out "first!" before anything else
 
```
 Specified by:
 
 toLazyCollection in interface ReactiveSeq<T>
 
 Specified by:
 
 toLazyCollection in interface Foldable<T>
 
 Returns:
 - toConcurrentLazyCollection
```
public CollectionX<T> toConcurrentLazyCollection()
```
 Lazily converts this SequenceM 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();
		System.out.println("first!");
		col.forEach(System.out::println);
 
 
 //Will print out "first!" before anything else
 
```
 Specified by:
 
 toConcurrentLazyCollection in interface ReactiveSeq<T>
 
 Specified by:
 
 toConcurrentLazyCollection in interface Foldable<T>
 
 Returns:
 - toLazyStreamable
```
public Streamable<T> toLazyStreamable()
```
 Returns:
 
 Streamable that can replay this SequenceM
 - toConcurrentLazyStreamable
```
public Streamable<T> toConcurrentLazyStreamable()
```
 Description copied from interface: ReactiveSeq
```
 {
 @code
 Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6).map(i -> i + 2).toConcurrentLazyStreamable();
 
 assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));
 assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));
 }
 
```
 Specified by:
 
 toConcurrentLazyStreamable in interface ReactiveSeq<T>
 
 Specified by:
 
 toConcurrentLazyStreamable in interface Foldable<T>
 
 Returns:
 
 Streamable that replay this SequenceM
 - reverse
```
public ReactiveSeq<T> reverse()
```
 Specified by:
 
 reverse in interface ReactiveSeq<T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 
 Specified by:
 
 reverse in interface org.jooq.lambda.Seq<T>
 - onClose
```
public ReactiveSeq<T> onClose(java.lang.Runnable closeHandler)
```
 Specified by:
 
 onClose in interface ReactiveSeq<T>
 
 Specified by:
 
 onClose in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
 
 Specified by:
 
 onClose in interface org.jooq.lambda.Seq<T>
 - close
```
public void close()
```
 Specified by:
 
 close in interface java.lang.AutoCloseable
 
 Specified by:
 
 close in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
 
 Specified by:
 
 close in interface org.jooq.lambda.Seq<T>
 - shuffle
```
public ReactiveSeq<T> shuffle()
```
 Specified by:
 
 shuffle in interface ReactiveSeq<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 
 Specified by:
 
 shuffle in interface org.jooq.lambda.Seq<T>
 - appendStream
```
public ReactiveSeq<T> appendStream(java.util.stream.Stream<T> stream)
```
 Append Stream to this SequenceM
```
 
 List<String> result = 	of(1,2,3).appendStream(of(100,200,300))
										.map(it ->it+"!!")
										.collect(Collectors.toList());
			assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
 
 
```
 Specified by:
 
 appendStream in interface ReactiveSeq<T>
 
 Parameters:
 
 stream - to append
 
 Returns:
 
 SequenceM with Stream appended
 - prependStream
```
public ReactiveSeq<T> prependStream(java.util.stream.Stream<T> stream)
```
 Prepend Stream to this SequenceM
```
 
 List<String> result = of(1,2,3).prependStream(of(100,200,300))
				.map(it ->it+"!!").collect(Collectors.toList());
			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 
 
 
```
 Specified by:
 
 prependStream in interface ReactiveSeq<T>
 
 Parameters:
 
 stream - to Prepend
 
 Returns:
 
 SequenceM with Stream prepended
 - append
```
public ReactiveSeq<T> append(T... values)
```
 Append values to the end of this SequenceM
```
 
 List<String> result = 	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<T>
 
 Specified by:
 
 append in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 values - to append
 
 Returns:
 
 SequenceM with appended values
 - prepend
```
public ReactiveSeq<T> prepend(T... values)
```
 Prepend given values to the start of the Stream
```
 
 List<String> result = 	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<T>
 
 Specified by:
 
 prepend in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 values - to prepend
 
 Returns:
 
 SequenceM with values prepended
 - insertAt
```
public ReactiveSeq<T> insertAt(int pos,
 T... values)
```
 Insert data into a stream at given position
```
 
 List<String> result = 	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<T>
 
 Parameters:
 
 pos - to insert data at
 
 values - to insert
 
 Returns:
 
 Stream with new data inserted
 - deleteBetween
```
public ReactiveSeq<T> deleteBetween(int start,
 int end)
```
 Delete elements between given indexes in a Stream
```
 
 List<String> result = 	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<T>
 
 Parameters:
 
 start - index
 
 end - index
 
 Returns:
 
 Stream with elements removed
 - insertStreamAt
```
public ReactiveSeq<T> insertStreamAt(int pos,
 java.util.stream.Stream<T> stream)
```
 Insert a Stream into the middle of this stream at the specified position
```
 
 List<String> result = 	of(1,2,3).insertStreamAt(1,of(100,200,300))
				.map(it ->it+"!!").collect(Collectors.toList());
			assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));
 
 
```
 Specified by:
 
 insertStreamAt in interface ReactiveSeq<T>
 
 Parameters:
 
 pos - to insert Stream at
 
 stream - to insert
 
 Returns:
 
 newly conjoined SequenceM
 - futureOperations
```
public FutureOperations<T> futureOperations(java.util.concurrent.Executor exec)
```
 Description copied from interface: ReactiveSeq
 
 Access asynchronous terminal operations (each returns a Future)
 
 Specified by:
 
 futureOperations in interface ReactiveSeq<T>
 
 Specified by:
 
 futureOperations in interface Traversable<T>
 
 Parameters:
 
 exec - Executor to use for Stream execution
 
 Returns:
 
 Async Future Terminal Operations
 - endsWithIterable
```
public boolean endsWithIterable(java.lang.Iterable<T> 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 ReactiveSeq<T>
 
 Specified by:
 
 endsWithIterable in interface Foldable<T>
 
 Parameters:
 
 iterable - Values to check
 
 Returns:
 
 true if ReactiveSeq ends with values in the supplied iterable
 - hotStream
```
public HotStream<T> hotStream(java.util.concurrent.Executor e)
```
 Description copied from interface: ReactiveSeq
 Turns this ReactiveSeq into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data. Note this method creates a HotStream that starts emitting data immediately. For a hotStream that waits until the first user streams connect @see ReactiveSeq.primedHotStream(Executor). The generated HotStream is not pausable, for a pausable HotStream @see ReactiveSeq.pausableHotStream(Executor). Turns this ReactiveSeq into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data
```
 
 HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
 											.hotStream(exec)
 											
 		
 		ints.connect().forEach(System.out::println);									
 //print out all the ints
 //multiple consumers are possible, so other Streams can connect on different Threads
 
 
 
```
 Specified by:
 
 hotStream in interface ReactiveSeq<T>
 
 Parameters:
 
 e - Executor to execute this ReactiveSeq on
 
 Returns:
 
 a Connectable HotStream
 - firstValue
```
public T 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 ReactiveSeq<T>
 
 Specified by:
 
 firstValue in interface Foldable<T>
 
 Returns:
 
 first value in this Stream
 - subscribe
```
public void subscribe(org.reactivestreams.Subscriber<? super T> sub)
```
 Specified by:
 
 subscribe in interface Traversable<T>
 
 Specified by:
 
 subscribe in interface org.reactivestreams.Publisher<T>
 - zip
```
public  ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
```
 Description copied from interface: ReactiveSeq
 Zip 2 streams into one
```
 {
 @code
 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
 // [[1,"a"],[2,"b"]]
 }
 
```
 Specified by:
 
 zip in interface ReactiveSeq<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq<T>
 - onEmpty
```
public ReactiveSeq<T> onEmpty(T value)
```
 Specified by:
 
 onEmpty in interface ReactiveSeq<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 
 Specified by:
 
 onEmpty in interface org.jooq.lambda.Seq<T>
 - onEmptyGet
```
public ReactiveSeq<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
 Specified by:
 
 onEmptyGet in interface ReactiveSeq<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 
 Specified by:
 
 onEmptyGet in interface org.jooq.lambda.Seq<T>
 - onEmptyThrow
```
public <X extends java.lang.Throwable> ReactiveSeq<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
 Specified by:
 
 onEmptyThrow in interface ReactiveSeq<T>
 
 Specified by:
 
 onEmptyThrow in interface Traversable<T>
 
 Specified by:
 
 onEmptyThrow in interface org.jooq.lambda.Seq<T>
 - concat
```
public ReactiveSeq<T> concat(java.util.stream.Stream<? extends T> other)
```
 Specified by:
 
 concat in interface ReactiveSeq<T>
 
 Specified by:
 
 concat in interface org.jooq.lambda.Seq<T>
 - concat
```
public ReactiveSeq<T> concat(T other)
```
 Specified by:
 
 concat in interface ReactiveSeq<T>
 
 Specified by:
 
 concat in interface org.jooq.lambda.Seq<T>
 - concat
```
public ReactiveSeq<T> concat(T... other)
```
 Specified by:
 
 concat in interface ReactiveSeq<T>
 
 Specified by:
 
 concat in interface org.jooq.lambda.Seq<T>
 - distinct
```
public  ReactiveSeq<T> distinct(java.util.function.Function<? super T,? extends U> keyExtractor)
```
 Specified by:
 
 distinct in interface ReactiveSeq<T>
 
 Specified by:
 
 distinct in interface org.jooq.lambda.Seq<T>
 - zip
```
public <U,R> ReactiveSeq<R> zip(org.jooq.lambda.Seq<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Specified by:
 
 zip in interface ReactiveSeq<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq<T>
 - shuffle
```
public ReactiveSeq<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface ReactiveSeq<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 
 Specified by:
 
 shuffle in interface org.jooq.lambda.Seq<T>
 - slice
```
public ReactiveSeq<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface ReactiveSeq<T>
 
 Specified by:
 
 slice in interface Traversable<T>
 
 Specified by:
 
 slice in interface org.jooq.lambda.Seq<T>
 - sorted
```
public > ReactiveSeq<T> sorted(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 sorted in interface ReactiveSeq<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq<T>
 - xPer
```
public ReactiveSeq<T> xPer(int x,
 long time,
 java.util.concurrent.TimeUnit t)
```
 Description copied from interface: ReactiveSeq
 emit x elements per time period
```
 {
 @code
 SimpleTimer timer = new SimpleTimer();
 assertThat(ReactiveSeq.of(1, 2, 3, 4, 5, 6).xPer(6, 100000000, TimeUnit.NANOSECONDS).collect(Collectors.toList()).size(), is(6));
 
 }
 
```
 Specified by:
 
 xPer in interface ReactiveSeq<T>
 
 Parameters:
 
 x - number of elements to emit
 
 time - period
 
 t - Time unit
 
 Returns:
 
 ReactiveSeq that emits x elements per time period
 - onePer
```
public ReactiveSeq<T> onePer(long time,
 java.util.concurrent.TimeUnit t)
```
 Description copied from interface: ReactiveSeq
 emit one element per time period
```
 
 ReactiveSeq.iterate("", last -> "next")
 				.limit(100)
 				.batchBySize(10)
 				.onePer(1, TimeUnit.MICROSECONDS)
 				.peek(batch -> System.out.println("batched : " + batch))
 				.flatMap(Collection::stream)
 				.peek(individual -> System.out.println("Flattened : "
 						+ individual))
 				.forEach(a->{});
 
```
 Specified by:
 
 onePer in interface ReactiveSeq<T>
 
 Parameters:
 
 time - period
 
 t - Time unit
 
 Returns:
 
 ReactiveSeq that emits 1 element per time period
 - debounce
```
public ReactiveSeq<T> debounce(long time,
 java.util.concurrent.TimeUnit t)
```
 Description copied from interface: ReactiveSeq
 Allow one element through per time period, drop all other elements in that time period
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .debounce(1000,TimeUnit.SECONDS).toList();
 
 // 1 
 
 
```
 Specified by:
 
 debounce in interface ReactiveSeq<T>
 
 Returns:
 - groupedBySizeAndTime
```
public ReactiveSeq<ListX<T>> groupedBySizeAndTime(int size,
 long time,
 java.util.concurrent.TimeUnit t)
```
 Description copied from interface: ReactiveSeq
 Batch elements by size into a List
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .batchBySizeAndTime(3,10,TimeUnit.SECONDS)
 .toList();
 
 //[[1,2,3],[4,5,6]] 
 
```
 Specified by:
 
 groupedBySizeAndTime in interface ReactiveSeq<T>
 
 Parameters:
 
 size - Max size of a batch
 
 time - (Max) time period to build a single batch in
 
 t - time unit for batch
 
 Returns:
 
 ReactiveSeq batched by size and time
 - groupedByTime
```
public ReactiveSeq<ListX<T>> groupedByTime(long time,
 java.util.concurrent.TimeUnit t)
```
 Description copied from interface: ReactiveSeq
 Batch elements in a Stream by time period
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6).batchByTime(1,TimeUnit.SECONDS).collect(Collectors.toList()).size(),is(1));
 assertThat(ReactiveSeq.of(1,2,3,4,5,6).batchByTime(1,TimeUnit.NANOSECONDS).collect(Collectors.toList()).size(),greaterThan(5));
 
 
```
 Specified by:
 
 groupedByTime in interface ReactiveSeq<T>
 
 Parameters:
 
 time - - time period to build a single batch in
 
 t - time unit for batch
 
 Returns:
 
 ReactiveSeq batched into lists by time period
 - foldRight
```
public T foldRight(T identity,
 java.util.function.BinaryOperator<T> accumulator)
```
 Description copied from interface: ReactiveSeq
 Immutable reduction from right to left
```
 
 assertTrue(ReactiveSeq.of("a","b","c").foldRight("", String::concat).equals("cba"));
 
 
```
 Specified by:
 
 foldRight in interface ReactiveSeq<T>
 
 Specified by:
 
 foldRight in interface Foldable<T>
 
 Returns:
 - endsWith
```
public boolean endsWith(java.util.stream.Stream<T> iterable)
```
 Description copied from interface: ReactiveSeq
```
 
 assertTrue(ReactiveSeq.of(1,2,3,4,5,6)
 				.endsWith(Stream.of(5,6))); 
 
 
```
 Specified by:
 
 endsWith in interface ReactiveSeq<T>
 
 Specified by:
 
 endsWith in interface Foldable<T>
 
 Parameters:
 
 iterable - Values to check
 
 Returns:
 
 true if ReactiveSeq endswith values in the supplied Stream
 - skip
```
public ReactiveSeq<T> skip(long time,
 java.util.concurrent.TimeUnit unit)
```
 Description copied from interface: ReactiveSeq
 Skip all elements until specified time period has passed
```
 {
 @code
 List<Integer> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).peek(i -> sleep(i * 100)).skip(1000, TimeUnit.MILLISECONDS).toList();
 
 // [4,5,6]
 
 }
 
```
 Specified by:
 
 skip in interface ReactiveSeq<T>
 
 Parameters:
 
 time - Length of time
 
 unit - Time unit
 
 Returns:
 
 ReactiveSeq that skips all elements until time period has elapsed
 - limit
```
public ReactiveSeq<T> limit(long time,
 java.util.concurrent.TimeUnit unit)
```
 Description copied from interface: ReactiveSeq
 Return all elements until specified time period has elapsed
```
 {
 @code
 List<Integer> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).peek(i -> sleep(i * 100)).limit(1000, TimeUnit.MILLISECONDS).toList();
 
 // [1,2,3,4]
 }
 
```
 Specified by:
 
 limit in interface ReactiveSeq<T>
 
 Parameters:
 
 time - Length of time
 
 unit - Time unit
 
 Returns:
 
 ReactiveSeq that returns all elements until time period has elapsed
 - fixedDelay
```
public ReactiveSeq<T> fixedDelay(long l,
 java.util.concurrent.TimeUnit unit)
```
 Description copied from interface: ReactiveSeq
 emit elements after a fixed delay
```
 {
 @code
 SimpleTimer timer = new SimpleTimer();
 assertThat(ReactiveSeq.of(1, 2, 3, 4, 5, 6).fixedDelay(10000, TimeUnit.NANOSECONDS).collect(Collectors.toList()).size(), is(6));
 assertThat(timer.getElapsedNanoseconds(), greaterThan(60000l));
 }
 
```
 Specified by:
 
 fixedDelay in interface ReactiveSeq<T>
 
 Parameters:
 
 l - time length in nanos of the delay
 
 unit - for the delay
 
 Returns:
 
 ReactiveSeq that emits each element after a fixed delay
 - jitter
```
public ReactiveSeq<T> jitter(long l)
```
 Description copied from interface: ReactiveSeq
 Introduce a random jitter / time delay between the emission of elements
```
 {
 @code
 SimpleTimer timer = new SimpleTimer();
 assertThat(ReactiveSeq.of(1, 2, 3, 4, 5, 6).jitter(10000).collect(Collectors.toList()).size(), is(6));
 assertThat(timer.getElapsedNanoseconds(), greaterThan(20000l));
 }
 
```
 Specified by:
 
 jitter in interface ReactiveSeq<T>
 
 Parameters:
 
 l - - random number less than this is used for each jitter
 
 Returns:
 
 Sequence with a random jitter between element emission
 - groupedUntil
```
public ReactiveSeq<ListX<T>> groupedUntil(java.util.function.Predicate<? super T> 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<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 Returns:
 
 ReactiveSeq batched into lists determined by the predicate supplied
 - groupedWhile
```
public ReactiveSeq<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> 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<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 Returns:
 
 ReactiveSeq batched into lists determined by the predicate supplied
 - groupedWhile
```
public <C extends java.util.Collection<? super T>> ReactiveSeq<C> groupedWhile(java.util.function.Predicate<? super T> 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<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 ReactiveSeq batched into collections determined by the predicate supplied
 - groupedUntil
```
public <C extends java.util.Collection<? super T>> ReactiveSeq<C> groupedUntil(java.util.function.Predicate<? super T> 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<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 ReactiveSeq batched into collections determined by the predicate supplied
 - groupedBySizeAndTime
```
public <C extends java.util.Collection<? super T>> ReactiveSeq<C> groupedBySizeAndTime(int size,
 long time,
 java.util.concurrent.TimeUnit unit,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: ReactiveSeq
 Batch elements by size into a collection created by the supplied factory
```
 {
 @code
 List<ArrayList<Integer>> list = of(1, 2, 3, 4, 5, 6).batchBySizeAndTime(10, 1, TimeUnit.MICROSECONDS, () -> new ArrayList<>()).toList();
 }
 
```
 Specified by:
 
 groupedBySizeAndTime in interface ReactiveSeq<T>
 
 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
 - groupedByTime
```
public <C extends java.util.Collection<? super T>> ReactiveSeq<C> groupedByTime(long time,
 java.util.concurrent.TimeUnit unit,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: ReactiveSeq
 Batch elements by time into a collection created by the supplied factory
```
 
 assertThat(ReactiveSeq.of(1,1,1,1,1,1)
 .batchByTime(1500,TimeUnit.MICROSECONDS,()-> new TreeSet<>())
 .toList()
 .get(0)
 .size(),is(1));
 
 
```
 Specified by:
 
 groupedByTime in interface ReactiveSeq<T>
 
 Parameters:
 
 time - - time period to build a single batch in
 
 unit - time unit for batch
 
 factory - Collection factory
 
 Returns:
 
 ReactiveSeq batched into collection types by time period
 - grouped
```
public <C extends java.util.Collection<? super T>> ReactiveSeq<C> grouped(int size,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: ReactiveSeq
 Batch elements in a Stream by size into a collection created by the supplied factory
```
 
 assertThat(ReactiveSeq.of(1,1,1,1,1,1)
 .batchBySize(3,()->new TreeSet<>())
 .toList()
 .get(0)
 .size(),is(1));
 
```
 Specified by:
 
 grouped in interface ReactiveSeq<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 size - batch size
 
 factory - Collection factory
 
 Returns:
 
 ReactiveSeq batched into collection types by size
 - skipLast
```
public ReactiveSeq<T> 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<T>
 
 Specified by:
 
 skipLast in interface Traversable<T>
 
 Returns:
 - limitLast
```
public ReactiveSeq<T> 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<T>
 
 Specified by:
 
 limitLast in interface Traversable<T>
 
 Parameters:
 
 num - of elements to return (last elements)
 
 Returns:
 
 ReactiveSeq limited to last num elements
 - recover
```
public ReactiveSeq<T> recover(java.util.function.Function<java.lang.Throwable,? extends T> 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<T>
 
 Parameters:
 
 fn - Function that accepts a Throwable and returns an alternative value
 
 Returns:
 
 ReactiveSeq that can recover from an Exception
 - recover
```
public <EX extends java.lang.Throwable> ReactiveSeq<T> recover(java.lang.Class<EX> exceptionClass,
 java.util.function.Function<EX,? extends T> 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<T>
 
 Parameters:
 
 exceptionClass - Type to recover from
 
 fn - That accepts an error and returns an alternative value
 
 Returns:
 
 Sequence that can recover from a particular exception
 - forEach3
```
public <R1,R2,R> ReactiveSeq<R> forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2,
 java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
```
 Perform a three level nested internal iteration over this Stream and the supplied streams
```
 
 ReactiveSeq.of(1,2)
						.forEach3(a->IntStream.range(10,13),
						.a->b->Stream.of(""+(a+b),"hello world"),
									a->b->c->c+":"a+":"+b);
									
 
 //SequenceM[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<T>
 
 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:
 
 SequenceM with elements generated via nested iteration
 - forEach3
```
public <R1,R2,R> ReactiveSeq<R> forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2,
 java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction,
 java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
```
 Perform a three level nested internal iteration over this Stream and the supplied streams
 
 Specified by:
 
 forEach3 in interface ReactiveSeq<T>
 
 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:
 
 SequenceM with elements generated via nested iteration
 - forEach2
```
public <R1,R> ReactiveSeq<R> forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
```
 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);
									
 
 /SequenceM[11,14,12,15,13,16]
 
 
```
 Specified by:
 
 forEach2 in interface ReactiveSeq<T>
 
 Parameters:
 
 stream1 - Nested Stream to iterate over
 
 yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
 
 Returns:
 
 SequenceM with elements generated via nested iteration
 - forEach2
```
public <R1,R> ReactiveSeq<R> forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
 java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction,
 java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
```
 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);
									
 
 //SequenceM[14,15]
 
 
```
 Specified by:
 
 forEach2 in interface ReactiveSeq<T>
 
 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:
 
 SequenceM with elements generated via nested iteration
 - forEachX
```
public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachX(long numberOfElements,
 java.util.function.Consumer<? super T> consumer)
```
 Description copied from interface: ReactiveStreamsTerminalOperations
 Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription e.g.
 Specified by:
 
 forEachX in interface ReactiveStreamsTerminalOperations<T>
 
 Parameters:
 
 numberOfElements - To consume from the Stream at this time
 
 consumer - To accept incoming events from the Stream
 
 Returns:
 
 Subscription so that further processing can be continued or cancelled.
 - forEachXWithError
```
public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachXWithError(long numberOfElements,
 java.util.function.Consumer<? super T> consumer,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError)
```
 Description copied from interface: ReactiveStreamsTerminalOperations
 Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription
 Specified by:
 
 forEachXWithError in interface ReactiveStreamsTerminalOperations<T>
 
 Parameters:
 
 numberOfElements - To consume from the Stream at this time
 
 consumer - To accept incoming elements from the Stream
 
 consumerError - To accept incoming processing errors from the Stream
 
 Returns:
 
 Subscription so that further processing can be continued or cancelled.
 - forEachXEvents
```
public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachXEvents(long numberOfElements,
 java.util.function.Consumer<? super T> consumer,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError,
 java.lang.Runnable onComplete)
```
 Description copied from interface: ReactiveStreamsTerminalOperations
 Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription, when the entire Stream has been processed an onComplete event will be recieved.
 Specified by:
 
 forEachXEvents in interface ReactiveStreamsTerminalOperations<T>
 
 Parameters:
 
 numberOfElements - To consume from the Stream at this time
 
 consumer - To accept incoming elements from the Stream
 
 consumerError - To accept incoming processing errors from the Stream
 
 onComplete - To run after an onComplete event
 
 Returns:
 
 Subscription so that further processing can be continued or cancelled.
 - forEachWithError
```
public <X extends java.lang.Throwable> void forEachWithError(java.util.function.Consumer<? super T> consumerElement,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError)
```
 Description copied from interface: ReactiveStreamsTerminalOperations
 Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,
 Specified by:
 
 forEachWithError in interface ReactiveStreamsTerminalOperations<T>
 
 consumerError - To accept incoming processing errors from the Stream
 - forEachEvent
```
public <X extends java.lang.Throwable> void forEachEvent(java.util.function.Consumer<? super T> consumerElement,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError,
 java.lang.Runnable onComplete)
```
 Description copied from interface: ReactiveStreamsTerminalOperations
 Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers when the entire Stream has been processed an onComplete event will be recieved.
 Specified by:
 
 forEachEvent in interface ReactiveStreamsTerminalOperations<T>
 
 consumerError - To accept incoming processing errors from the Stream
 
 onComplete - To run after an onComplete event
 - primedHotStream
```
public HotStream<T> primedHotStream(java.util.concurrent.Executor e)
```
 Description copied from interface: ReactiveSeq
 Return a HotStream that will start emitting data when the first connecting Stream connects. Note this method creates a HotStream that starts emitting data only when the first connecting Stream connects. For a hotStream that starts to output data immediately @see ReactiveSeq.hotStream(Executor). The generated HotStream is not pausable, for a pausable HotStream @see ReactiveSeq.primedPausableHotStream(Executor).
```
 
 HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
											.hotStream(exec)
											
		
		ints.connect().forEach(System.out::println);									
 //print out all the ints - starting when connect is called.
 //multiple consumers are possible, so other Streams can connect on different Threads
 
 
 
```
 Specified by:
 
 primedHotStream in interface ReactiveSeq<T>
 
 Returns:
 - pausableHotStream
```
public PausableHotStream<T> pausableHotStream(java.util.concurrent.Executor e)
```
 Description copied from interface: ReactiveSeq
 Turns this ReactiveSeq into a HotStream, a connectable & pausable Stream, being executed on a thread on the supplied executor, that is producing data. Note this method creates a HotStream that starts emitting data immediately. For a hotStream that waits until the first user streams connect @see ReactiveSeq.primedPausableHotStream(Executor). The generated HotStream is pausable, for a unpausable HotStream (slightly faster execution) @see ReactiveSeq.hotStream(Executor).
```
 
 HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
											.hotStream(exec)
											
		
		ints.connect().forEach(System.out::println);
		
		ints.pause(); //on a separate thread pause the generating Stream
											
 //print out all the ints
 //multiple consumers are possible, so other Streams can connect on different Threads
 
 
 
```
 Specified by:
 
 pausableHotStream in interface ReactiveSeq<T>
 
 Parameters:
 
 e - Executor to execute this ReactiveSeq on
 
 Returns:
 
 a Connectable HotStream
 - primedPausableHotStream
```
public PausableHotStream<T> primedPausableHotStream(java.util.concurrent.Executor e)
```
 Description copied from interface: ReactiveSeq
 Return a pausable HotStream that will start emitting data when the first connecting Stream connects. Note this method creates a HotStream that starts emitting data only when the first connecting Stream connects. For a hotStream that starts to output data immediately @see ReactiveSeq.pausableHotStream(Executor). The generated HotStream is pausable, for a unpausable HotStream @see ReactiveSeq.primedHotStream(Executor).
```
 
 HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
											.hotStream(exec)
											
		
		ints.connect().forEach(System.out::println);									
 //print out all the ints - starting when connect is called.
 //multiple consumers are possible, so other Streams can connect on different Threads
 
 
 
```
 Specified by:
 
 primedPausableHotStream in interface ReactiveSeq<T>
 
 Returns:
 - format
```
public java.lang.String format()
```
 Specified by:
 
 format in interface org.jooq.lambda.Seq<T>
 - collectable
```
public org.jooq.lambda.Collectable<T> collectable()
```
 Description copied from interface: CyclopsCollectable
 
 Narrow this class to a Collectable
 
 Specified by:
 
 collectable in interface ReactiveSeq<T>
 
 Specified by:
 
 collectable in interface IterableFunctor<T>
 
 Specified by:
 
 collectable in interface CyclopsCollectable<T>
 
 Returns:
 
 Collectable
 - unitIterator
```
public <T> ReactiveSeq<T> unitIterator(java.util.Iterator<T> it)
```
 Specified by:
 
 unitIterator in interface ReactiveSeq<T>
 
 Specified by:
 
 unitIterator in interface IterableFunctor<T>
 - append
```
public ReactiveSeq<T> append(T value)
```
 Specified by:
 
 append in interface ReactiveSeq<T>
 
 Specified by:
 
 append in interface org.jooq.lambda.Seq<T>
 - prepend
```
public ReactiveSeq<T> prepend(T value)
```
 Specified by:
 
 prepend in interface ReactiveSeq<T>
 
 Specified by:
 
 prepend in interface org.jooq.lambda.Seq<T>

Class ReactiveSeqImpl<T>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

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

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

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

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

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

Methods inherited from interface org.jooq.lambda.Seq

Methods inherited from interface java.util.stream.Stream

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

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

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

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

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

Constructor Detail

ReactiveSeqImpl

ReactiveSeqImpl

Method Detail

reduce

unit

schedule

scheduleFixedDelay

scheduleFixedRate

unwrap

flatten

unwrapStream

cycle

cycle

duplicateSequence

triplicate

quadruplicate

splitSequenceAtHead

splitAt

splitBy

partitionSequence

cycle

cycle

cycleWhile

cycleUntil

zip

zip3

zip4

zipStream

sliding

sliding

grouped

groupedStatefullyWhile

groupBy

distinct

scanLeft

scanLeft

scanRight

scanRight

sorted

sorted

skip

skipWhile

skipUntil

limit

limitWhile

limitUntil

parallel

allMatch

anyMatch

xMatch

noneMatch

join

join

join

minBy

min

maxBy

max

headAndTail

findFirst