ReactiveSeqImpl (cyclops-reactor 8.4.2 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>, OnEmpty<T>, OnEmptySwitch<T,java.util.stream.Stream<T>>, ConvertableSequence<T>, CyclopsCollectable<T>, JoolManipulation<T>, JoolWindowing<T>, ReactiveStreamsTerminalOperations<T>, To<ReactiveSeq<T>>, TransformerTraversable<T>, Traversable<T>, Unit<T>, Unwrapable, Zippable<T>, 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 ReactiveSeq
`ReactiveSeq<T>`	`append(T value)`
`ReactiveSeq<T>`	`appendStream(java.util.stream.Stream<T> stream)` Append Stream to this ReactiveSeq
`<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)`
`<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
`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)`
`ReactiveSeq<java.lang.Character>`	`flatMapCharSequence(java.util.function.Function<? super T,java.lang.CharSequence> fn)`
`<R> ReactiveSeq<R>`	`flatMapCompletableFuture(java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)`
`ReactiveSeq<java.lang.String>`	`flatMapFile(java.util.function.Function<? super T,java.io.File> fn)`
`<R> ReactiveSeq<R>`	`flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)` FlatMap where the result is a Collection, flattens the resultant collections into the host ReactiveSeq
`<R> ReactiveSeq<R>`	`flatMapOptional(java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)`
`<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)`
`<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)`
`<T> T`	`foldLeftMapToType(Reducer<T> reducer)`
`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)`
`<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>>`	`groupedStatefullyUntil(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 Example :
`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(),ReactiveSeq.of(1, 2, 3).join().length());`
`java.lang.String`	`join(java.lang.String sep)` `assertEquals("1, 2, 3".length(), ReactiveSeq.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(ReactiveSeq.of(4,3,6,7).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)` Take elements from the Stream until the predicate returns true, after which all elements are excluded.
`ReactiveSeq<T>`	`limitWhile(java.util.function.Predicate<? super T> p)` Take elements from the Stream while the predicate holds, once the predicate returns false all subsequent elements are excluded
`<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 Sequence to the same type as the supplied Monoid (Reducer) 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)`
`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)`
`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)` If this Container instance is empty, create a new instance containing the provided value
`ReactiveSeq<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)` If this Container instance is empty, create a new instance containing the value returned from the provided Supplier
`<X extends java.lang.Throwable> ReactiveSeq<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is empty, throw the exception returned by the provided 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 ReactiveSeq
`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)` An equivalent function to `Stream.reduce(BinaryOperator)`
`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 streamedMonad() 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 streamedMonad() first.
`T`	`reduce(T identity, java.util.function.BinaryOperator<T> accumulator)` An equivalent function to `Stream.reduce(Object, BinaryOperator)`
`<U> U`	`reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator)` An equivalent function to `Stream.reduce(Object, BinaryOperator)`
`<U> U`	`reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner)` An equivalent function to `Stream.reduce(Object, BiFunction, BinaryOperator)`
`ReactiveSeq<T>`	`reverse()` Potentially efficient Stream reversal.
`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(ReactiveSeq.of(4,3,6,7).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)` Drop elements from the Stream until the predicate returns true, after which all elements are included
`ReactiveSeq<T>`	`skipWhile(java.util.function.Predicate<? super T> p)` SkipWhile drops elements from the Stream while the predicate holds, once the predicte returns true all subsequent elements are included *
`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(ReactiveSeq.of(4,3,6,7).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(ReactiveSeq.of(1,2,3,4).startsWith(Stream.of(1,2,3)))`
`boolean`	`startsWithIterable(java.lang.Iterable<T> iterable)` `assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));`
`ReactiveSeq<T>`	`stream()` Convert this ReactiveSeq 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 ReactiveSeq into a Collection.
`Streamable<T>`	`toConcurrentLazyStreamable()` `Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6).map(i -> i + 2).toConcurrentLazyStreamable(); assertThat(repeat.stream().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12))); assertThat(repeat.stream().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));`
`CollectionX<T>`	`toLazyCollection()` Lazily converts this ReactiveSeq 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.stream().toList(); //Arrays.asList(2,4,6,8,10,12)); repeat.stream().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)` Create an IterableFunctor instance of the same type from an Iterator
`ReactiveSeq<T>`	`unordered()`
`<R> R`	`unwrap()` Deprecated.
`java.util.stream.Stream<T>`	`unwrapStream()`
`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)` Zip (combine) this Zippable with the supplied Seq, using the supplied combining function
`<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 Stream with another

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, append, append, append, append, applicatives, avg, avg, avgDouble, avgInt, avgLong, coflatMap, combinations, combinations, combine, concat, concat, concat, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, crossApply, crossJoin, crossJoin, crossJoin, cycle, drop, dropRight, dropUntil, dropWhile, elapsed, elementAt, empty, fill, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, fromDoubleStream, fromIntStream, fromIterable, fromIterator, fromList, fromLongStream, fromPublisher, fromStream, generate, get, grouped, grouped, innerJoin, innerJoin, innerJoin, innerJoin, iterate, leftOuterJoin, leftOuterJoin, leftOuterJoin, leftOuterJoin, limitUntilClosed, limitWhileClosed, max, max, max, maxBy, median, median, medianBy, medianBy, min, min, min, minBy, mode, of, onEmptySwitch, outerApply, patternMatch, percentile, percentile, percentileBy, percentileBy, permutations, prepend, prepend, prepend, prepend, print, print, printErr, printOut, range, rangeLong, remove, retry, retry, reversedListOf, reversedOf, rightOuterJoin, rightOuterJoin, rightOuterJoin, single, single, singleOptional, size, skipUntilClosed, skipWhileClosed, sliding, sorted, subscriber, subStream, sum, sum, sumDouble, sumInt, sumLong, take, 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.To
to

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
groupedStatefullyUntilT, 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, foldFuture, foldLazy, foldTry, 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
cast, concat, concat, concat, concat, contains, containsAll, containsAll, containsAll, containsAll, containsAny, containsAny, containsAny, containsAny, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, crossApply, 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, duplicate, duplicate, findFirst, findLast, findLast, findSingle, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, generate, groupBy, groupBy, groupBy, groupBy, groupBy, grouped, grouped, grouped, grouped, grouped, grouped, indexOf, indexOf, intersperse, isEmpty, isNotEmpty, join, join, join, join, join, limit, limitUntil, limitUntilClosed, limitWhile, limitWhileClosed, ofType, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, outerApply, partition, partition, 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, seq, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, skip, skipUntil, skipUntilClosed, skipWhile, skipWhileClosed, slice, splitAt, splitAt, splitAtHead, splitAtHead, toCollection, toList, toMap, toMap, toSet, toString, toString, transform, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, window, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipWithIndex, zipWithIndex, zipWithIndex

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

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

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

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

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

Methods inherited from interface com.aol.cyclops.types.Zippable
zip

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)
```
 Description copied from interface: Foldable
 
 An equivalent function to Stream.reduce(Object, BinaryOperator)
 
 Specified by:
 
 reduce in interface Foldable<T>
 
 Parameters:
 
 identity - Identity value for the combiner function (leaves the input unchanged)
 
 accumulator - Combiner function
 
 Returns:
 
 Value produced by applying the current accumulated value and the next value to the combiner function as this Foldable is traversed from left to right
 - 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
```
 
 
 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
```
 
 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
```
 
 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()
```
 Description copied from interface: ReactiveSeq
 join / flatten one level of a nested hierarchy
```
 
 ReactiveSeq.of(Arrays.asList(1,2)).flatten();
 
 //stream of (1, 2);		
 
 
 
 
 
 
```
 Specified by:
 
 flatten in interface ReactiveSeq<T>
 
 Returns:
 
 Flattened / joined one level
 - unwrapStream
```
public final java.util.stream.Stream<T> unwrapStream()
```
 - cycle
```
public final ReactiveSeq<T> cycle(int times)
```
 Description copied from interface: ReactiveSeq
 Convert to a Stream with the values repeated specified times
```
 
 		ReactiveSeq.of(1,2,2)
 								.cycle(3)
 								.collect(Collectors.toList());
 								
 		//List[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()
```
 Description copied from interface: ReactiveSeq
 Convert to a Stream with the values infinitely cycled
```
 
 ReactiveSeq.of(1).cycle().limit(6).toList());
 //List[1, 1, 1, 1, 1,1]
 
 
```
 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()
```
 Description copied from interface: ReactiveSeq
 Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.
```
 
 
 	Tuple2<ReactiveSeq<Integer>, ReactiveSeq<Integer>> copies = of(1, 2, 3, 4, 5, 6)
 .duplicate();
 	assertTrue(copies.v1.anyMatch(i > i == 2));
 	assertTrue(copies.v2.anyMatch(i > i == 2));
 
 
 
```
 Specified by:
 
 duplicateSequence in interface ReactiveSeq<T>
 
 Returns:
 
 duplicated stream
 - triplicate
```
public final org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> triplicate()
```
 Description copied from interface: ReactiveSeq
 Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.
```
 
 	Tuple3<ReactiveSeq<Tuple3<T1, T2, T3>>, ReactiveSeq<Tuple3<T1, T2, T3>>, ReactiveSeq<Tuple3<T1, T2, T3>>> Tuple3 = sequence.triplicate();
 
 
 
```
 Specified by:
 
 triplicate in interface ReactiveSeq<T>
 - quadruplicate
```
public final org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> quadruplicate()
```
 Description copied from interface: ReactiveSeq
 Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.
```
 
 	Tuple4<ReactiveSeq<Tuple4<T1, T2, T3, T4>>, 
 ReactiveSeq<Tuple4<T1, T2, T3, T4>>, 
 ReactiveSeq<Tuple4<T1, T2, T3, T4>>, 
 ReactiveSeq<Tuple4<T1, T2, T3, T4>>> quad = sequence.quadruplicate();
 
 
 
```
 Specified by:
 
 quadruplicate in interface ReactiveSeq<T>
 
 Returns:
 
 Tuple4 containing 4 duplicated ReactiveSeqs
 - splitSequenceAtHead
```
public final org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,ReactiveSeq<T>> splitSequenceAtHead()
```
 Description copied from interface: ReactiveSeq
 Split a Stream at it's head (similar to headAndTail)
```
 
 ReactiveSeq.of(1,2,3)
 .splitAtHead()
 
 //Optional[1], ReactiveSeq[2,3]
 
 
 
```
 Specified by:
 
 splitSequenceAtHead in interface ReactiveSeq<T>
 - splitAt
```
public final org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> splitAt(int where)
```
 Description copied from interface: ReactiveSeq
 Split at supplied location
```
 
 ReactiveSeq.of(1,2,3)
 .splitAt(1)
 
 //ReactiveSeq[1], ReactiveSeq[2,3]
 
 
 
```
 Specified by:
 
 splitAt in interface ReactiveSeq<T>
 - splitBy
```
public final org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> splitBy(java.util.function.Predicate<T> splitter)
```
 Description copied from interface: ReactiveSeq
 Split stream at point where predicate no longer holds
```
 
 ReactiveSeq.of(1, 2, 3, 4, 5, 6).splitBy(i->i<4)
 
 //ReactiveSeq[1,2,3] ReactiveSeq[4,5,6]
 
 
```
 Specified by:
 
 splitBy in interface ReactiveSeq<T>
 - partitionSequence
```
public final org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> partitionSequence(java.util.function.Predicate<T> splitter)
```
 Description copied from interface: ReactiveSeq
 Partition a Stream into two one a per element basis, based on predicate's boolean value
```
 
 ReactiveSeq.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0) 
 
 //ReactiveSeq[1,3,5], ReactiveSeq[2,4,6]
 

 
```
 Specified by:
 
 partitionSequence in interface ReactiveSeq<T>
 - cycle
```
public final ReactiveSeq<T> cycle(Monoid<T> m,
 int times)
```
 Description copied from interface: ReactiveSeq
 Convert to a Stream with the result of a reduction operation repeated specified times
```
 
 List<Integer> list = ReactiveSeq.of(1,2,2))
 .cycle(Reducers.toCountInt(),3)
 .collect(Collectors.toList());
 //List[3,3,3];
 
 
```
 Specified by:
 
 cycle in interface ReactiveSeq<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
 - cycleWhile
```
public final ReactiveSeq<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: ReactiveSeq
 Repeat in a Stream while specified predicate holds
```
 
 	
 	MutableInt count = MutableInt.of(0);
 	ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6)
 .collect(Collectors.toList());
 
 	// List(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)
```
 Description copied from interface: ReactiveSeq
 Repeat in a Stream until specified predicate holds
```
 
 	MutableInt count =MutableInt.of(0);
 		ReactiveSeq.of(1,2,2)
 		 		.cycleUntil(next -> count.get()>6)
 		 		.peek(i-> count.mutate(i->i+1))
 		 		.collect(Collectors.toList());
 
 		//List[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)
```
 Description copied from interface: ReactiveSeq
 Zip 2 streams into one
```
 
 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
 // [[1,"a"],[2,"b"]]
 
 
```
 Specified by:
 
 zip in interface ReactiveSeq<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 second - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - 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)
```
 Description copied from interface: ReactiveSeq
 zip 3 Streams into one
```
 
 List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(Collectors.toList());
 
 // [[1,100,'a'],[2,200,'b'],[3,300,'c']]
 
 
 
```
 Specified by:
 
 zip3 in interface ReactiveSeq<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)
```
 Description copied from interface: ReactiveSeq
 zip 4 Streams into 1
```
 
 List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
 .collect(Collectors.toList());
 
 
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 
```
 Specified by:
 
 zip4 in interface ReactiveSeq<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)
```
 Description copied from interface: ReactiveSeq
 Zip this Stream with another
```
 
 Stream<List<Integer>> zipped = ReactiveSeq.of(1, 2, 3)).zipStream(Stream.of(2, 3, 4), (a, b) -> Arrays.asList(a, b));
 
 // [[1,2][2,3][3,4]] 
 
 
```
 Specified by:
 
 zipStream in interface ReactiveSeq<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)
```
 Description copied from interface: ReactiveSeq
 Create a sliding view over this Sequence
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).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:
 
 ReactiveSeq with sliding view
 - sliding
```
public final ReactiveSeq<ListX<T>> sliding(int windowSize,
 int increment)
```
 Description copied from interface: ReactiveSeq
 Create a sliding view over this Sequence
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).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:
 
 ReactiveSeq with sliding view
 - grouped
```
public final ReactiveSeq<ListX<T>> grouped(int groupSize)
```
 Description copied from interface: ReactiveSeq
 Group elements in a Stream
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(4, 5, 6));
 
 
 
```
 Specified by:
 
 grouped in interface ReactiveSeq<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - groupedStatefullyUntil
```
public ReactiveSeq<ListX<T>> groupedStatefullyUntil(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
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .groupedStatefullyUntil((s,i)-> s.contains(4) ? true : false)
 .toList()
 .size()
 //5
 
 
```
 Specified by:
 
 groupedStatefullyUntil in interface ReactiveSeq<T>
 
 Specified by:
 
 groupedStatefullyUntil 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)
```
 Description copied from interface: ReactiveSeq
 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)
```
 Description copied from interface: ReactiveSeq
 Scan left using supplied Monoid
```
 
 
 	assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
 													.scanLeft(Reducers.toString("")).toList());
 
 
 
```
 Specified by:
 
 scanLeft in interface ReactiveSeq<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Returns:
 
 ReactiveSeq with values combined scanning left
 - scanLeft
```
public final  ReactiveSeq scanLeft(U seed,
 java.util.function.BiFunction<? super U,? super T,? extends U> function)
```
 Description copied from interface: ReactiveSeq
 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)
```
 Description copied from interface: ReactiveSeq
 Scan right
```
 
 assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
 is(asList("", "c", "bc", "abc").size()));
 
 
```
 Specified by:
 
 scanRight in interface ReactiveSeq<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)
```
 Description copied from interface: ReactiveSeq
 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()
```
 Description copied from interface: ReactiveSeq
```
 assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); 
 
```
 Specified by:
 
 sorted in interface ReactiveSeq<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)
```
 Description copied from interface: ReactiveSeq
```
 
 	assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
 
 
```
 Specified by:
 
 sorted in interface ReactiveSeq<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 Stream
 - skip
```
public final ReactiveSeq<T> skip(long num)
```
 Description copied from interface: ReactiveSeq
```
 assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
 Specified by:
 
 skip in interface 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:
 
 Stream with specified number of elements skipped
 - skipWhile
```
public final ReactiveSeq<T> skipWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: ReactiveSeq
 SkipWhile drops elements from the Stream while the predicate holds, once the predicte returns true all subsequent elements are included *
```
 
 assertThat(ReactiveSeq.of(4,3,6,7).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:
 
 Stream with elements skipped while predicate holds
 - skipUntil
```
public final ReactiveSeq<T> skipUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: ReactiveSeq
 Drop elements from the Stream until the predicate returns true, after which all elements are included
```
 assertThat(ReactiveSeq.of(4,3,6,7).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:
 
 Stream with elements skipped until predicate holds
 - limit
```
public final ReactiveSeq<T> limit(long num)
```
 Description copied from interface: ReactiveSeq
```
 assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
 
```
 Specified by:
 
 limit in interface ReactiveSeq<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)
```
 Description copied from interface: ReactiveSeq
 Take elements from the Stream while the predicate holds, once the predicate returns false all subsequent elements are excluded
```
 assertThat(ReactiveSeq.of(4,3,6,7).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:
 
 Stream with limited elements
 - limitUntil
```
public final ReactiveSeq<T> limitUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: ReactiveSeq
 Take elements from the Stream until the predicate returns true, after which all elements are excluded.
```
 assertThat(ReactiveSeq.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:
 
 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 ReactiveSeq is for Sequential Streams
 - allMatch
```
public final boolean allMatch(java.util.function.Predicate<? super T> c)
```
 Description copied from interface: ReactiveSeq
 True if predicate matches all elements when Monad converted to a Stream
```
 
 assertThat(ReactiveSeq.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)
```
 Description copied from interface: ReactiveSeq
 True if a single element matches when Monad converted to a Stream
```
 
 assertThat(ReactiveSeq.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)
```
 Description copied from interface: ReactiveSeq
 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()
```
 Description copied from interface: ReactiveSeq
```
 
 assertEquals("123".length(),ReactiveSeq.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)
```
 Description copied from interface: ReactiveSeq
```
 
 assertEquals("1, 2, 3".length(), ReactiveSeq.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)
```
 Description copied from interface: ReactiveSeq
```
 
 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)
```
 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)
```
 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()
```
 Description copied from interface: IterableFoldable
 extract head and tail together, where head is expected to be present Example :
```
 
 ReactiveSeq<String> helloWorld = ReactiveSeq.Of("hello","world","last");
 HeadAndTail<String> headAndTail = helloWorld.headAndTail();
 String head = headAndTail.head();
 
 //head == "hello"
 
 ReactiveSeq<String> tail = headAndTail.tail();
 //["world","last]
 
 
 
```
 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
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findFirst().get(); //3
 (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
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findAny().get(); //3
 (non-deterministic)
 - mapReduce
```
public final <R> R mapReduce(Reducer<R> reducer)
```
 Description copied from interface: ReactiveSeq
 Attempt to map this Sequence to the same type as the supplied Monoid (Reducer) Then use Monoid to reduce values
```
 
 ReactiveSeq.of("hello","2","world","4").mapReduce(Reducers.toCountInt());
 
 //4
 
 
```
 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)
```
 Description copied from interface: ReactiveSeq
 Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values
```
 
 ReactiveSeq.of("one","two","three","four")
 .mapReduce(this::toInt,Reducers.toTotalInt());
 
 //10
 
 int toInt(String s){
 		if("one".equals(s))
 			return 1;
 		if("two".equals(s))
 			return 2;
 		if("three".equals(s))
 			return 3;
 		if("four".equals(s))
 			return 4;
 		return -1;
 	 }
 
 
```
 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)
```
 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>
 - 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)
```
 Description copied from interface: Foldable
 An equivalent function to Stream.reduce(BinaryOperator)
```
 
 
 ReactiveSeq.of(1,2,3,4,5).map(it -> it*100).reduce(
 (acc,next) -> acc+next)
 //Optional[1500]
 
 
```
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Specified by:
 
 reduce in interface Foldable<T>
 
 Specified by:
 
 reduce in interface java.util.stream.Stream<T>
 
 Parameters:
 
 accumulator - Combiner function
 
 Returns:
 - reduce
```
public final T reduce(T identity,
 java.util.function.BinaryOperator<T> accumulator)
```
 Description copied from interface: Foldable
 
 An equivalent function to Stream.reduce(Object, BinaryOperator)
 
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Specified by:
 
 reduce in interface Foldable<T>
 
 Specified by:
 
 reduce in interface java.util.stream.Stream<T>
 
 accumulator - Combiner function
 
 Returns:
 
 Value produced by applying the current accumulated value and the next value to the combiner function as this Foldable is traversed from left to right
 - reduce
```
public final  U reduce(U identity,
 java.util.function.BiFunction<U,? super T,U> accumulator,
 java.util.function.BinaryOperator combiner)
```
 Description copied from interface: Foldable
 
 An equivalent function to Stream.reduce(Object, BiFunction, BinaryOperator)
 
 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)
```
 Description copied from interface: ReactiveSeq
 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 streamedMonad() first. I.e. streamedMonad().reduce(reducer)
```
 
 Monoid<Integer> sum = Monoid.of(0, (a, b) -> a + b);
 Monoid<Integer> mult = Monoid.of(1, (a, b) -> a * b);
 List<Integer> result = ReactiveSeq.of(1, 2, 3, 4).reduce(Arrays.asList(sum, mult).stream());
 
 assertThat(result, equalTo(Arrays.asList(10, 24)));
 
 
 
```
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Specified by:
 
 reduce in interface Foldable<T>
 
 Returns:
 
 List of reduced values
 - reduce
```
public final ListX<T> reduce(java.lang.Iterable<? extends Monoid<T>> reducers)
```
 Description copied from interface: ReactiveSeq
 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 streamedMonad() first. I.e. streamedMonad().reduce(reducer)
```
 
 Monoid<Integer> sum = Monoid.of(0,(a,b)->a+b);
 		Monoid<Integer> mult = Monoid.of(1,(a,b)->a*b);
 		List<Integer> result = ReactiveSeq.of(1,2,3,4))
 										.reduce(Arrays.asList(sum,mult) );
 				
 		 
 		assertThat(result,equalTo(Arrays.asList(10,24)));
 
 
```
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Specified by:
 
 reduce in interface Foldable<T>
 
 Returns:
 - foldLeft
```
public final T foldLeft(Monoid<T> reducer)
```
 - foldLeft
```
public final T foldLeft(T identity,
 java.util.function.BinaryOperator<T> accumulator)
```
 - foldLeftMapToType
```
public final <T> T foldLeftMapToType(Reducer<T> reducer)
```
 - 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)
```
 Description copied from interface: Foldable
 
 Immutable reduction from right to left
 
 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:
 
 seed - Identity value for the combiner function (leaves the input unchanged)
 
 function - Combining function
 
 Returns:
 
 Reduced value
 - foldRightMapToType
```
public final <T> T foldRightMapToType(Reducer<T> reducer)
```
 Description copied from interface: ReactiveSeq
 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
```
 
 		ReactiveSeq.of(1,2,3).foldRightMapToType(Reducers.toString(""));
 
 // "321"
 
 
```
 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.stream().toList(); //Arrays.asList(2,4,6,8,10,12));
 		repeat.stream().toList() //Arrays.asList(2,4,6,8,10,12));
 
 
```
 Specified by:
 
 toStreamable in interface ReactiveSeq<T>
 
 Specified by:
 
 toStreamable in interface ConvertableSequence<T>
 
 Returns:
 
 Lazily Convert to a repeatable Streamable
 - 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 Stream 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 Stream 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()
```
 Description copied from interface: ReactiveSeq
 
 Convert this ReactiveSeq into a Stream
 
 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>
 
 Returns:
 
 This Traversable converted to a Stream
 - startsWithIterable
```
public final boolean startsWithIterable(java.lang.Iterable<T> iterable)
```
 Description copied from interface: ReactiveSeq
```
 
 assertTrue(ReactiveSeq.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>
 
 Returns:
 
 True if Monad starts with Iterable sequence of data
 - startsWith
```
public final boolean startsWith(java.util.stream.Stream<T> stream2)
```
 Description copied from interface: ReactiveSeq
```
 assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Stream.of(1,2,3))) 
 
```
 Specified by:
 
 startsWith in interface ReactiveSeq<T>
 
 Specified by:
 
 startsWith in interface Foldable<T>
 
 Parameters:
 
 stream2 - Stream to check if this Foldable has the same elements in the same order, at the start
 
 Returns:
 
 True if Monad starts with Iterators sequence of data
 - anyM
```
public AnyMSeq<T> anyM()
```
 Specified by:
 
 anyM in interface ReactiveSeq<T>
 
 Returns:
 
 this ReactiveSeq 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)
```
 Description copied from interface: ReactiveSeq
 flatMap operation
```
 
 	assertThat(ReactiveSeq.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)
```
 Description copied from interface: ReactiveSeq
 Allows flatMap return type to be any Monad type
```
 
 	assertThat(ReactiveSeq.of(1,2,3)).flatMapAnyM(i-> anyM(CompletableFuture.completedFuture(i+2))).toList(),equalTo(Arrays.asList(3,4,5)));
 
 
 
```
 Specified by:
 
 flatMapAnyM in interface ReactiveSeq<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)
```
 Description copied from interface: ReactiveSeq
 FlatMap where the result is a Collection, flattens the resultant collections into the host ReactiveSeq
```
 
 	ReactiveSeq.of(1,2)
 			.flatMap(i -> asList(i, -i))
 .toList();
 
 //1,-1,2,-2 
 
 
```
 Specified by:
 
 flatMapIterable in interface ReactiveSeq<T>
 
 Returns:
 - flatMapStream
```
public final <R> ReactiveSeq<R> flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)
```
 Description copied from interface: ReactiveSeq
 flatMap operation
```
 
 	assertThat(ReactiveSeq.of(1,2,3)
 .flatMapStream(i->IntStream.of(i))
 .toList(),equalTo(Arrays.asList(1,2,3)));
 
 
 
```
 Specified by:
 
 flatMapStream in interface ReactiveSeq<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)
```
 - flatMapCompletableFuture
```
public final <R> ReactiveSeq<R> flatMapCompletableFuture(java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)
```
 - flatMapCharSequence
```
public final ReactiveSeq<java.lang.Character> flatMapCharSequence(java.util.function.Function<? super T,java.lang.CharSequence> fn)
```
 - flatMapFile
```
public final ReactiveSeq<java.lang.String> flatMapFile(java.util.function.Function<? super T,java.io.File> fn)
```
 - flatMapURL
```
public final ReactiveSeq<java.lang.String> flatMapURL(java.util.function.Function<? super T,java.net.URL> fn)
```
 - flatMapBufferedReader
```
public final ReactiveSeq<java.lang.String> flatMapBufferedReader(java.util.function.Function<? super T,java.io.BufferedReader> fn)
```
 - 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)
```
 Description copied from interface: ReactiveSeq
 
 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)
```
 Description copied from interface: ReactiveSeq
 
 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)
```
 Description copied from interface: ReactiveSeq
 
 Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)
 
 Specified by:
 
 cast in interface ReactiveSeq<T>
 
 Specified by:
 
 cast in interface Functor<T>
 
 Specified by:
 
 cast in interface org.jooq.lambda.Seq<T>
 - toLazyCollection
```
public CollectionX<T> toLazyCollection()
```
 Description copied from interface: ReactiveSeq
 Lazily converts this ReactiveSeq into a Collection. This does not trigger the Stream. E.g. Collection is not thread safe on the first iteration.
```
 
 Collection<Integer> col = ReactiveSeq.of(1, 2, 3, 4, 5)
 .peek(System.out::println)
 .toLazyCollection();
 
 col.forEach(System.out::println);
 
 
 // Will print out "first!" before anything else
 
```
 Specified by:
 
 toLazyCollection in interface ReactiveSeq<T>
 
 Specified by:
 
 toLazyCollection in interface Foldable<T>
 
 Returns:
 
 Lazy Collection
 - toConcurrentLazyCollection
```
public CollectionX<T> toConcurrentLazyCollection()
```
 Description copied from interface: ReactiveSeq
 Lazily converts this ReactiveSeq into a Collection. This does not trigger the Stream. E.g.
```
 
 Collection<Integer> col = ReactiveSeq.of(1, 2, 3, 4, 5).peek(System.out::println).toConcurrentLazyCollection();
 
 col.forEach(System.out::println);
 
 
 // Will print out "first!" before anything else
 
```
 Specified by:
 
 toConcurrentLazyCollection in interface ReactiveSeq<T>
 
 Specified by:
 
 toConcurrentLazyCollection in interface Foldable<T>
 
 Returns:
 
 Concurrent Lazy Collection
 - toLazyStreamable
```
public Streamable<T> toLazyStreamable()
```
 - toConcurrentLazyStreamable
```
public Streamable<T> toConcurrentLazyStreamable()
```
 Description copied from interface: ReactiveSeq
```
 
 Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6).map(i -> i + 2).toConcurrentLazyStreamable();
 
 assertThat(repeat.stream().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));
 assertThat(repeat.stream().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));
 
 
```
 Specified by:
 
 toConcurrentLazyStreamable in interface ReactiveSeq<T>
 
 Specified by:
 
 toConcurrentLazyStreamable in interface Foldable<T>
 
 Returns:
 
 Streamable that replay this ReactiveSeq, populated lazily and can be populated across threads
 - reverse
```
public ReactiveSeq<T> reverse()
```
 Description copied from interface: Traversable
 Potentially efficient Stream reversal. Is efficient if - Sequence created via a range - Sequence created via a List - Sequence created via an Array / var args Otherwise Sequence collected into a Collection prior to reversal
```
 assertThat( of(1, 2, 3).reverse().toList(),
 equalTo(asList(3, 2, 1))); 
```
 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)
```
 Description copied from interface: ReactiveSeq
 Append Stream to this ReactiveSeq
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3).appendStream(ReactiveSeq.of(100, 200, 300)).map(it -> it + "!!").collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!"))); * 
 
```
 Specified by:
 
 appendStream in interface ReactiveSeq<T>
 
 Parameters:
 
 stream - to append
 
 Returns:
 
 ReactiveSeq with Stream appended
 - prependStream
```
public ReactiveSeq<T> prependStream(java.util.stream.Stream<T> stream)
```
 Description copied from interface: ReactiveSeq
 Prepend Stream to this ReactiveSeq
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3)
 .prependStream(of(100, 200, 300))
 .map(it -> it + "!!")
 .collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
 
 
```
 Specified by:
 
 prependStream in interface ReactiveSeq<T>
 
 Parameters:
 
 stream - to Prepend
 
 Returns:
 
 ReactiveSeq with Stream prepended
 - append
```
public ReactiveSeq<T> append(T... values)
```
 Description copied from interface: ReactiveSeq
 Append values to the end of this ReactiveSeq
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3).append(100, 200, 300).map(it -> it + "!!").collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!"))); * 
 
```
 Specified by:
 
 append in interface ReactiveSeq<T>
 
 Specified by:
 
 append in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 values - to append
 
 Returns:
 
 ReactiveSeq with appended values
 - prepend
```
public ReactiveSeq<T> prepend(T... values)
```
 Description copied from interface: ReactiveSeq
 Prepend given values to the start of the Stream
```
 
 List<String> result = 	ReactiveSeq.of(1,2,3)
 									 .prepend(100,200,300)
 										 .map(it ->it+"!!")
 										 .collect(Collectors.toList());
 
 			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 
```
 Specified by:
 
 prepend in interface ReactiveSeq<T>
 
 Specified by:
 
 prepend in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 values - to prepend
 
 Returns:
 
 ReactiveSeq with values prepended
 - insertAt
```
public ReactiveSeq<T> insertAt(int pos,
 T... values)
```
 Description copied from interface: ReactiveSeq
 Insert data into a stream at given position
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3).insertAt(1, 100, 200, 300).map(it -> it + "!!").collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!"))); * 
 
 
```
 Specified by:
 
 insertAt in interface ReactiveSeq<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)
```
 Description copied from interface: ReactiveSeq
 Delete elements between given indexes in a Stream
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).deleteBetween(2, 4).map(it -> it + "!!").collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "5!!", "6!!"))); * 
 
```
 Specified by:
 
 deleteBetween in interface ReactiveSeq<T>
 
 Parameters:
 
 start - index
 
 end - index
 
 Returns:
 
 Stream with elements removed
 - insertStreamAt
```
public ReactiveSeq<T> insertStreamAt(int pos,
 java.util.stream.Stream<T> stream)
```
 Description copied from interface: ReactiveSeq
 Insert a Stream into the middle of this stream at the specified position
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3).insertStreamAt(1, of(100, 200, 300)).map(it -> it + "!!").collect(Collectors.toList());
 
 assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
 
 
```
 Specified by:
 
 insertStreamAt in interface ReactiveSeq<T>
 
 Parameters:
 
 pos - to insert Stream at
 
 stream - to insert
 
 Returns:
 
 newly conjoined ReactiveSeq
 - 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
```
 
 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 Zippable<T>
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 other - Seq to combine with
 
 Returns:
 
 Combined Zippable
 - onEmpty
```
public ReactiveSeq<T> onEmpty(T value)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is empty, create a new instance containing the provided value
 
 Specified by:
 
 onEmpty in interface ReactiveSeq<T>
 
 Specified by:
 
 onEmpty in interface OnEmpty<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 
 Specified by:
 
 onEmpty in interface org.jooq.lambda.Seq<T>
 
 Returns:
 
 New instance containing value if container is empty, otherwise returns this container
 - onEmptyGet
```
public ReactiveSeq<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is empty, create a new instance containing the value returned from the provided Supplier
 
 Specified by:
 
 onEmptyGet in interface ReactiveSeq<T>
 
 Specified by:
 
 onEmptyGet in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 
 Specified by:
 
 onEmptyGet in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 supplier - to determine new value for container
 
 Returns:
 
 New Container with value if this is empty, otherwise this container
 - onEmptyThrow
```
public <X extends java.lang.Throwable> ReactiveSeq<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
 Description copied from interface: OnEmpty
 
 If this container instance is empty, throw the exception returned by the provided Supplier
 
 Specified by:
 
 onEmptyThrow in interface ReactiveSeq<T>
 
 Specified by:
 
 onEmptyThrow in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyThrow in interface Traversable<T>
 
 Specified by:
 
 onEmptyThrow in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 supplier - to create exception from
 
 Returns:
 
 Throw exception if empty, otherwise this container
 - 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)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Seq, using the supplied combining function
 
 Specified by:
 
 zip in interface ReactiveSeq<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Specified by:
 
 zip in interface org.jooq.lambda.Seq<T>
 
 Parameters:
 
 other - Seq to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - 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();
 	ReactiveSeq.of(1, 2, 3, 4, 5, 6)
 .xPer(6, 100000000, TimeUnit.NANOSECONDS)
 .collect(Collectors.toList())
 .size();
 //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>
 
 Parameters:
 
 time - Time to apply debouncing over
 
 t - Time unit for debounce period
 
 Returns:
 
 ReactiveSeq with debouncing applied
 - 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)
 .groupedBySizeAndTime(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>
 
 Parameters:
 
 identity - Identity value for the combiner function (leaves the input unchanged)
 
 accumulator - Combining function
 
 Returns:
 
 Reduced value
 - 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
```
 
 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
```
 
 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
```
 
 	SimpleTimer timer = new SimpleTimer();
 	ReactiveSeq.of(1, 2, 3, 4, 5, 6)
 .fixedDelay(10000, TimeUnit.NANOSECONDS)
 .collect(Collectors.toList())
 .size();
 //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();
 ReactiveSeq.of(1, 2, 3, 4, 5, 6)
 .jitter(10000)
 .collect(Collectors.toList());
 
 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:
 
 ReactiveSeq 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
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .groupedBySizeAndTime(3,10,TimeUnit.SECONDS,()->SetX.empty())
 .toList();
 
 //[[1,2,3],[4,5,6]] 
 
 
```
 Specified by:
 
 groupedBySizeAndTime in interface ReactiveSeq<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:
 
 ReactiveSeq that can recover from a particular exception
 - 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.
```
 
 Subscription next = ReactiveSeq.of(1,2,3,4)
 					 .forEachX(2,System.out::println);
 
 System.out.println("First batch processed!");
 
 next.request(2);
 
 System.out.println("Second batch processed!");
 
 //prints
 1
 2
 First batch processed!
 3
 4 
 Second batch processed!
 
 
```
 Specified by:
 
 forEachX in interface ReactiveStreamsTerminalOperations<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
```
 
 Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
 .map(Supplier::get)
 					 .forEachXWithError(2,System.out::println, e->e.printStackTrace());
 
 System.out.println("First batch processed!");
 
 next.request(2);
 
 System.out.println("Second batch processed!");
 
 //prints
 1
 2
 First batch processed!
 
 RuntimeException Stack Trace on System.err
 
 4 
 Second batch processed!
 
 
```
 Specified by:
 
 forEachXWithError in interface ReactiveStreamsTerminalOperations<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.
```
 
 Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
 .map(Supplier::get)
 					 .forEachXEvents(2,System.out::println, e->e.printStackTrace(),()->System.out.println("the end!"));
 
 System.out.println("First batch processed!");
 
 next.request(2);
 
 System.out.println("Second batch processed!");
 
 //prints
 1
 2
 First batch processed!
 
 RuntimeException Stack Trace on System.err
 
 4 
 Second batch processed!
 The end!
 
 
```
 Specified by:
 
 forEachXEvents in interface ReactiveStreamsTerminalOperations<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,
```
 
 Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
 .map(Supplier::get)
 					 .forEachWithError(System.out::println, e->e.printStackTrace());
 
 System.out.println("processed!");
 
 
 
 //prints
 1
 2
 RuntimeException Stack Trace on System.err
 4
 processed!
 
 
 
```
 Specified by:
 
 forEachWithError in interface ReactiveStreamsTerminalOperations<T>
 
 Parameters:
 
 consumerElement - To accept incoming elements from the Stream
 
 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.
```
 
 Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
 .map(Supplier::get)
 					 .forEachEvents(System.out::println, e->e.printStackTrace(),()->System.out.println("the end!"));
 
 System.out.println("processed!");
 
 
 //prints
 1
 2
 RuntimeException Stack Trace on System.err
 4 
 processed!
 
 
 
 
```
 Specified by:
 
 forEachEvent in interface ReactiveStreamsTerminalOperations<T>
 
 Parameters:
 
 consumerElement - To accept incoming elements from the Stream
 
 consumerError - To accept incoming processing errors from the Stream
 
 onComplete - To run after an onComplete event
 - 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)
```
 Description copied from interface: IterableFunctor
 Create an IterableFunctor instance of the same type from an Iterator
```
 
 ReactiveSeq<Integer> newSeq = seq.unitIterator(myIterator);
 
 
 
```
 Specified by:
 
 unitIterator in interface ReactiveSeq<T>
 
 Specified by:
 
 unitIterator in interface IterableFunctor<T>
 
 Parameters:
 
 it - Iterator to create new IterableFunctor from
 
 Returns:
 
 New IterableFunctor instance
 - 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.To

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

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

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

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

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

Methods inherited from interface org.jooq.lambda.Seq

Methods inherited from interface java.util.stream.Stream

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

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

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

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

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

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

cycleWhile

cycleUntil

zip

zip3

zip4

zipStream

sliding

sliding

grouped

groupedStatefullyUntil

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