FluxReactiveSeq (cyclops-reactor 9.0.0-FINAL API)

java.lang.Object
- com.aol.cyclops.reactor.adapter.FluxReactiveSeq<T>

All Implemented Interfaces:

Convert<Higher<Witness.reactiveSeq,T>>, Higher<Witness.reactiveSeq,T>, Unit<T>, Filters<T>, CyclopsCollectable<T>, Folds<T>, To<ReactiveSeq<T>>, FilterableTransformable<T>, Transformable<T>, TransformerTraversable<T>, ReactiveStreamsTerminalOperations<T>, OnEmpty<T>, OnEmptySwitch<T,java.util.stream.Stream<T>>, ExtendedTraversable<T>, FoldableTraversable<T>, IterableFilterable<T>, Sequential<T>, Traversable<T>, Zippable<T>, ReactiveSeq<T>, java.lang.AutoCloseable, java.lang.Iterable<T>, java.util.stream.BaseStream<T,java.util.stream.Stream<T>>, java.util.stream.Stream<T>, org.reactivestreams.Publisher<T>
```
public class FluxReactiveSeq<T>
extends java.lang.Object
implements ReactiveSeq<T>
```

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

Constructor Summary

Constructors
Constructor and Description

FluxReactiveSeq()

Constructors
Constructor and Description
`FluxReactiveSeq()`

Method Summary

All Methods Instance Methods Concrete 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<Witness.reactiveSeq,T>`	`anyM()`
`boolean`	`anyMatch(java.util.function.Predicate<? super T> c)` True if a singleUnsafe element matches when Monad converted to a Stream
`ReactiveSeq<T>`	`append(java.lang.Iterable<? extends T> other)`
`ReactiveSeq<T>`	`append(T... values)` Append values to the take of this ReactiveSeq
`ReactiveSeq<T>`	`append(T value)`
`ReactiveSeq<T>`	`appendS(java.util.stream.Stream<? extends T> other)` Append Stream to this ReactiveSeq
`ReactiveSeq<T>`	`changes()`
`void`	`close()`
`<R> ReactiveSeq<R>`	`coflatMap(java.util.function.Function<? super ReactiveSeq<T>,? extends R> fn)` coflatMap pattern, can be used to perform maybe reductions / collections / folds and other terminal operations
`<R,A> R`	`collect(java.util.stream.Collector<? super T,A,R> collector)` Performs a mutable reduction operation on the elements of this reactiveStream using a `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)` Performs a mutable reduction operation on the elements of this reactiveStream.
`<R,A> ReactiveSeq<R>`	`collectStream(java.util.stream.Collector<? super T,A,R> collector)`
`ReactiveSeq<T>`	`complete(java.lang.Runnable fn)` Provide a simpler method to handle stream or async operations.
`long`	`count()` Returns the count of elements in this reactiveStream.
`ReactiveSeq<T>`	`cycle()` Convert to a Stream with the values infinitely cycled
`ReactiveSeq<T>`	`cycle(long times)` Convert to a Stream with the values repeated specified times
`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>`	`distinct()`
`<U> ReactiveSeq<T>`	`distinct(java.util.function.Function<? super T,? extends U> keyExtractor)`
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`duplicate()` Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading reactiveStream.
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`duplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)`
`boolean`	`endsWith(java.util.stream.Stream<T> stream)` `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()`
`Either<java.lang.Throwable,T>`	`findFirstOrError()` Lazy / reactiveBuffer look up of first value , capturing the first error, if one occurs.
`Maybe<T>`	`findOne()` Lazy / reactiveBuffer analogue of findFirst / findAny from JDK For push based reactiveBuffer-streams (created via Spouts.XXX) data will be pushed to the returned Maybe on arrival.
`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<Witness.stream,? extends R>> fn)` Allows flatMap return type to be any Monad type
`<R> ReactiveSeq<R>`	`flatMapI(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>`	`flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`<R> ReactiveSeq<R>`	`flatMapP(int maxConcurrency, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? 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)`
`<R> FluxReactiveSeq<R>`	`flux(reactor.core.publisher.Flux<R> flux)`
`<R> FluxReactiveSeq<R>`	`flux(ReactiveSeq<R> flux)`
`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 identity, java.util.function.BiFunction<? super T,? super U,? extends U> accumulator)` Immutable reduction from right to left
`<T1> T1`	`foldRightMapToType(Reducer<T1> 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)` Performs an action for each element of this Stream.
`void`	`forEachAsync(java.util.function.Consumer<? super T> action)` A potentially non-blocking analog of `ReactiveSeq.forEach(java.util.function.Consumer<? super T>)`.
`void`	`forEachOrdered(java.util.function.Consumer<? super T> action)`
`<X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachSubscribe(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`	`forEachSubscribe(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.
`<X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachSubscribe(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.
`java.lang.String`	`format()`
`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> supplier)` Batch elements in a Stream by size into a toX 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 toX created by the supplied factory
`<C extends java.util.Collection<? super T>,R> ReactiveSeq<R>`	`groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)`
`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 toX created by the supplied factory
`<C extends java.util.Collection<? super T>,R> ReactiveSeq<R>`	`groupedByTime(long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)`
`<C extends java.util.Collection<T>,R> ReactiveSeq<R>`	`groupedStatefullyUntil(java.util.function.BiPredicate<C,? super T> predicate, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)`
`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.
`ListT<Witness.reactiveSeq,T>`	`groupedStatefullyUntilT(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)` List Transformer view into batched Lists where each List is populated while the supplied bipredicate holds.
`<C extends java.util.Collection<T>,R> ReactiveSeq<R>`	`groupedStatefullyWhile(java.util.function.BiPredicate<C,? super T> predicate, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)`
`ReactiveSeq<ListX<T>>`	`groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)`
`ListT<Witness.reactiveSeq,T>`	`groupedT(int groupSize)` Group the elements in this Traversable into batches of the provided size.
`ListT<Witness.reactiveSeq,T>`	`groupedUntilT(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, 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
`ListT<Witness.reactiveSeq,T>`	`groupedWhileT(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, 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 :
`boolean`	`isParallel()`
`java.util.Iterator<T>`	`iterator()`
`ReactiveSeq<T>`	`jitter(long maxJitterPeriodInNanos)` 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>`	`limitUntilClosed(java.util.function.Predicate<? super T> p)`
`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
`ReactiveSeq<T>`	`limitWhileClosed(java.util.function.Predicate<? super T> p)`
`<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
`boolean`	`noneMatch(java.util.function.Predicate<? super T> c)`
`ReactiveSeq<T>`	`onClose(java.lang.Runnable closeHandler)`
`ReactiveSeq<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)` If this Container instance is zero, create a new instance containing the value returned from the provided Supplier
`ReactiveSeq<T>`	`onEmptySwitch(java.util.function.Supplier<? extends java.util.stream.Stream<T>> switchTo)` If this ReactiveSeq is empty one it with a another Stream
`<X extends java.lang.Throwable> ReactiveSeq<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is zero, 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>>`	`partition(java.util.function.Predicate<? super T> splitter)` Partition a Stream into two one a per element basis, based on predicate's boolean value
`ReactiveSeq<T>`	`prepend(java.lang.Iterable<? extends T> other)`
`ReactiveSeq<T>`	`prepend(T... values)` Prepend given values to the skip of the Stream
`ReactiveSeq<T>`	`prepend(T value)`
`ReactiveSeq<T>`	`prependS(java.util.stream.Stream<? extends T> stream)` Prepend Stream to this ReactiveSeq
`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 reactiveStream.
`org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>`	`quadruplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)`
`<EX extends java.lang.Throwable> ReactiveSeq<T>`	`recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<? super EX,? extends T> fn)` Recover from a particular exception type
`ReactiveSeq<T>`	`recover(java.util.function.Function<? super 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, java.util.function.BinaryOperator<U> combiner)` An equivalent function to `Stream.reduce(Object, BiFunction, BinaryOperator)`
`ReactiveSeq<T>`	`reverse()` Potentially efficient Stream reversal.
`<U> ReactiveSeq<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`ReactiveSeq<T>`	`sequential()`
`Maybe<T>`	`single()` `//Maybe[1] ReactiveSeq.of(1).singleUnsafe(); //Maybe.none ReactiveSeq.of().singleUnsafe(); //Maybe.none ReactiveSeq.of(1,2,3).singleUnsafe();`
`Maybe<T>`	`single(java.util.function.Predicate<? super T> predicate)`
`T`	`singleUnsafe()` `//1 ReactiveSeq.of(1).singleUsafe(); //UnsupportedOperationException ReactiveSeq.of().singleUnsafe(); //UnsupportedOperationException ReactiveSeq.of(1,2,3).singleUnsafe();`
`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(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
`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>`	`skipWhileClosed(java.util.function.Predicate<? super T> predicate)`
`ReactiveSeq<VectorX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`ListT<Witness.reactiveSeq,T>`	`slidingT(int windowSize)` Create a Sliding window into the data in this traversble.
`ListT<Witness.reactiveSeq,T>`	`slidingT(int windowSize, int increment)` Create a Sliding window into the data in this traversble.
`ReactiveSeq<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`splitAt(int where)` Split at supplied location
`org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,ReactiveSeq<T>>`	`splitAtHead()` Split a Stream at it's head (similar to headAndTail)
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`splitBy(java.util.function.Predicate<T> splitter)` Split reactiveStream at point where predicate no longer holds
`java.util.Spliterator<T>`	`spliterator()` Returns a spliterator for the elements of this reactiveStream.
`boolean`	`startsWith(java.util.stream.Stream<T> stream)` `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> s)`
`java.lang.Object[]`	`toArray()`
`<A> A[]`	`toArray(java.util.function.IntFunction<A[]> generator)`
`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 reactiveStream.
`org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>`	`triplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)`
`<T1> ReactiveSeq<T1>`	`unit(T1 unit)`
`<U> Traversable<U>`	`unitIterator(java.util.Iterator<U> U)` Create an IterableFunctor instance of the same type from an Iterator
`ReactiveSeq<T>`	`unordered()`
`<R> R`	`visit(java.util.function.Function<? super ReactiveSeq<T>,? extends R> sync, java.util.function.Function<? super ReactiveSeq<T>,? extends R> reactiveStreams, java.util.function.Function<? super ReactiveSeq<T>,? extends R> asyncNoBackPressure)`
`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
`<S,U> ReactiveSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)` zip 3 Streams into one
`<T2,T3,T4> ReactiveSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)` zip 4 Streams into 1
`<U,R> ReactiveSeq<R>`	`zipLatest(org.reactivestreams.Publisher<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`<U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipP(org.reactivestreams.Publisher<? extends U> other)`
`<U,R> ReactiveSeq<R>`	`zipP(org.reactivestreams.Publisher<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`<U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipS(java.util.stream.Stream<? extends U> other)` Zip 2 streams into one
`<U,R> ReactiveSeq<R>`	`zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Stream, using the supplied combining function

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

Methods inherited from interface cyclops.stream.ReactiveSeq
allTypeclasses, allTypeclasses, ambWith, ambWith, backpressureAware, broadcast, cast, collectAll, combinations, combinations, combinationsT, combinationsT, combine, combine, concat, concat, concat, concat, concatDoubles, concatInts, concatLongs, coproduct, crossJoin, cycle, cycleUntil, cycleWhile, deferred, deferredI, deferredP, deleteBetween, doubles, drop, dropRight, dropUntil, dropWhile, elapsed, elementAt, empty, enqueued, enqueued, enqueued, enqueuedAll, enums, enums, enums, enumsFromTo, fanOut, fanOut, fanOut, fanOutZipIn, fanOutZipIn, fanOutZipIn, fill, filterInts, filterLongs, filterLongs, filterNot, flatMapDoubles, flatMapInts, flatMapLongs, flatten, flattenI, flattenO, foldJool, foldParallel, foldParallel, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, fromCharSequence, fromDoubleStream, fromIntStream, fromIterable, fromIterator, fromList, fromLongStream, fromPublisher, fromSpliterator, fromStream, generate, generate, get, groupBy, grouped, grouped, groupedUntil, groupedUntil, hotStream, insertAt, insertAtS, intersperse, ints, isEmpty, isReplayable, iterate, iterate, jool, kindCokleisli, kindKleisli, liftM, limitDouble, limitInts, limitLongs, longs, mapDoubles, mapInts, mapLongs, mapM, mapToDouble, mapToInt, mapToLong, max, merge, mergeP, mergeP, min, multicast, narrowK, nested, notNull, of, of, ofDoubles, ofInts, ofLongs, ofNullable, ofType, onEmpty, oneShotList, oneShotStream, parallel, parallel, parallelFanOut, parallelFanOut, parallelFanOut, parallelFanOutZipIn, parallelFanOutZipIn, parallelFanOutZipIn, pausableHotStream, peek, permutations, permutationsT, primedHotStream, primedPausableHotStream, print, print, printErr, printOut, product, product, publishTo, publishTo, range, range, rangeLong, rangeLong, reactiveSeq, reduce, reduceAll, remove, removeAll, removeAllI, removeAllS, retainAll, retainAllI, retainAllS, retry, retry, reversedListOf, reversedOf, scanLeft, scanRight, scanRight, schedule, scheduleFixedDelay, scheduleFixedRate, seq, shuffle, shuffle, size, skipDoubles, skipInts, skipLongs, skipUntil, skipUntilClosed, slice, sliding, sorted, sorted, sorted, subStream, tailRec, take, takeOne, takeRight, takeUntil, takeWhile, timestamp, toList, toSet, trampoline, unfold, unzip, unzip3, unzip4, widen, zip, zip, zip, zip3, zip4, zipWith, zipWithIndex, zipWithP, zipWithS

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

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

Methods inherited from interface com.aol.cyclops2.types.traversable.FoldableTraversable
asFunction, foldFuture, foldLazy, foldTry, forEach, forEach, forEach, forEach, forEach, runFuture, runLazy, toListX, toSetX, visit

Methods inherited from interface com.aol.cyclops2.types.foldable.CyclopsCollectable
collectors, commonPrefix, commonSuffix, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, maxBy, minBy, mode, sum, sumDouble, sumInt, sumLong, to, toMap, toMap, toString, toString

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

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

Methods inherited from interface com.aol.cyclops2.hkt.Higher
applyHKT_, applyHKT, applyHKT

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

- Constructor Detail
 - FluxReactiveSeq
```
public FluxReactiveSeq()
```
- Method Detail
 - flux
```
public <R> FluxReactiveSeq<R> flux(reactor.core.publisher.Flux<R> flux)
```
 - flux
```
public <R> FluxReactiveSeq<R> flux(ReactiveSeq<R> flux)
```
 - coflatMap
```
public <R> ReactiveSeq<R> coflatMap(java.util.function.Function<? super ReactiveSeq<T>,? extends R> fn)
```
 Description copied from interface: ReactiveSeq
 coflatMap pattern, can be used to perform maybe reductions / collections / folds and other terminal operations
```
 

 ReactiveSeq.of(1,2,3)
 .map(i->i*2)
 .coflatMap(s -> s.reduce(0,(a,b)->a+b))

 //ReactiveSeq[12]
 
 
```
 Specified by:
 
 coflatMap in interface ReactiveSeq<T>
 
 Returns:
 - unit
```
public <T1> ReactiveSeq<T1> unit(T1 unit)
```
 Specified by:
 
 unit in interface Unit<T>
 
 Specified by:
 
 unit in interface ReactiveSeq<T>
 - foldRight
```
public  U foldRight(U identity,
 java.util.function.BiFunction<? super T,? super U,? extends U> accumulator)
```
 Description copied from interface: Folds
 
 Immutable reduction from right to left
 
 Specified by:
 
 foldRight in interface Folds<T>
 
 Specified by:
 
 foldRight in interface ReactiveSeq<T>
 
 Parameters:
 
 identity - Identity value for the combiner function (leaves the input unchanged)
 
 accumulator - Combining function
 
 Returns:
 
 Reduced value
 - zipS
```
public <U,R> ReactiveSeq<R> zipS(java.util.stream.Stream<? 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 Stream, using the supplied combining function
 
 Specified by:
 
 zipS in interface Traversable<T>
 
 Specified by:
 
 zipS in interface Zippable<T>
 
 Specified by:
 
 zipS in interface ReactiveSeq<T>
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zipLatest
```
public <U,R> ReactiveSeq<R> zipLatest(org.reactivestreams.Publisher<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Specified by:
 
 zipLatest in interface ReactiveSeq<T>
 - zipP
```
public <U,R> ReactiveSeq<R> zipP(org.reactivestreams.Publisher<? 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 Publisher, using the supplied combining function
 
 Specified by:
 
 zipP in interface Traversable<T>
 
 Specified by:
 
 zipP in interface Zippable<T>
 
 Specified by:
 
 zipP in interface ReactiveSeq<T>
 
 Parameters:
 
 other - to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zipP
```
public  ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> zipP(org.reactivestreams.Publisher<? extends U> other)
```
 Specified by:
 
 zipP in interface Traversable<T>
 
 Specified by:
 
 zipP in interface Zippable<T>
 
 Specified by:
 
 zipP in interface ReactiveSeq<T>
 - cycle
```
public 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>
 
 Returns:
 
 Stream with values repeated
 - duplicate
```
public org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> duplicate()
```
 Description copied from interface: ReactiveSeq
 Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading reactiveStream. Not thread-safe.
```
 

 	Tuple2<ReactiveSeq<Integer>, ReactiveSeq<Integer>> copies = of(1, 2, 3, 4, 5, 6)
 .duplicate();
 	assertTrue(copies.v1.anyMatch(i > i == 2));
 	assertTrue(copies.v2.anyMatch(i > i == 2));

 
 
```
 Specified by:
 
 duplicate in interface ReactiveSeq<T>
 
 Returns:
 
 duplicated reactiveStream
 - duplicate
```
public org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> duplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
```
 Specified by:
 
 duplicate in interface ReactiveSeq<T>
 - triplicate
```
public 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 reactiveStream. 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>
 - triplicate
```
public org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> triplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
```
 Specified by:
 
 triplicate in interface ReactiveSeq<T>
 - quadruplicate
```
public 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 reactiveStream. 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
 - quadruplicate
```
public org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> quadruplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
```
 Specified by:
 
 quadruplicate in interface ReactiveSeq<T>
 - splitAtHead
```
public org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,ReactiveSeq<T>> splitAtHead()
```
 Description copied from interface: ReactiveSeq
 Split a Stream at it's head (similar to headAndTail)
```
 
 ReactiveSeq.of(1,2,3)
 .splitAtHead()

 //Optional[1], ReactiveSeq[2,3]
 

 
```
 Specified by:
 
 splitAtHead in interface ReactiveSeq<T>
 - splitAt
```
public 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 org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> splitBy(java.util.function.Predicate<T> splitter)
```
 Description copied from interface: ReactiveSeq
 Split reactiveStream 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>
 - partition
```
public org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> partition(java.util.function.Predicate<? super 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:
 
 partition in interface ReactiveSeq<T>
 - zipS
```
public  ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? 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:
 
 zipS in interface Traversable<T>
 
 Specified by:
 
 zipS in interface Zippable<T>
 
 Specified by:
 
 zipS in interface ReactiveSeq<T>
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - zip3
```
public <S,U> ReactiveSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second,
 java.lang.Iterable<? 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(CyclopsCollectors.toList());

 // [[1,100,'a'],[2,200,'b'],[3,300,'c']]
 

 
```
 Specified by:
 
 zip3 in interface Traversable<T>
 
 Specified by:
 
 zip3 in interface Zippable<T>
 
 Specified by:
 
 zip3 in interface ReactiveSeq<T>
 - zip4
```
public <T2,T3,T4> ReactiveSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
 java.lang.Iterable<? extends T3> third,
 java.lang.Iterable<? extends T4> fourth)
```
 Description copied from interface: ReactiveSeq
 zip 4 Streams into 1
```
 
 List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
 .collect(CyclopsCollectors.toList());

 
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 
```
 Specified by:
 
 zip4 in interface Traversable<T>
 
 Specified by:
 
 zip4 in interface Zippable<T>
 
 Specified by:
 
 zip4 in interface ReactiveSeq<T>
 - sliding
```
public ReactiveSeq<VectorX<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(CyclopsCollectors.toList());

 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(3, 4, 5));

 

 
```
 Specified by:
 
 sliding in interface Traversable<T>
 
 Specified by:
 
 sliding in interface ReactiveSeq<T>
 
 Parameters:
 
 windowSize - number of elements in each batch
 
 increment - for each window
 
 Returns:
 
 ReactiveSeq with sliding view
 - grouped
```
public 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(CyclopsCollectors.toList());

 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(4, 5, 6));

 
 
```
 Specified by:
 
 grouped in interface Traversable<T>
 
 Specified by:
 
 grouped in interface ReactiveSeq<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 Traversable<T>
 
 Specified by:
 
 groupedStatefullyUntil in interface ReactiveSeq<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 ReactiveSeq windowed while predicate holds
 - groupedStatefullyUntil
```
public <C extends java.util.Collection<T>,R> ReactiveSeq<R> groupedStatefullyUntil(java.util.function.BiPredicate<C,? super T> predicate,
 java.util.function.Supplier<C> factory,
 java.util.function.Function<? super C,? extends R> finalizer)
```
 Specified by:
 
 groupedStatefullyUntil in interface ReactiveSeq<T>
 - groupedStatefullyWhile
```
public ReactiveSeq<ListX<T>> groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
```
 Specified by:
 
 groupedStatefullyWhile in interface ReactiveSeq<T>
 - groupedStatefullyWhile
```
public <C extends java.util.Collection<T>,R> ReactiveSeq<R> groupedStatefullyWhile(java.util.function.BiPredicate<C,? super T> predicate,
 java.util.function.Supplier<C> factory,
 java.util.function.Function<? super C,? extends R> finalizer)
```
 Specified by:
 
 groupedStatefullyWhile in interface ReactiveSeq<T>
 - 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 singleUnsafe batch in
 
 t - time unit for batch
 
 Returns:
 
 ReactiveSeq batched by size and time
 - 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 toX 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 singleUnsafe batch in
 
 unit - time unit for batch
 
 factory - Collection factory
 
 Returns:
 
 ReactiveSeq batched by size and time
 - groupedBySizeAndTime
```
public <C extends java.util.Collection<? super T>,R> ReactiveSeq<R> groupedBySizeAndTime(int size,
 long time,
 java.util.concurrent.TimeUnit unit,
 java.util.function.Supplier<C> factory,
 java.util.function.Function<? super C,? extends R> finalizer)
```
 Specified by:
 
 groupedBySizeAndTime in interface ReactiveSeq<T>
 - groupedByTime
```
public <C extends java.util.Collection<? super T>,R> ReactiveSeq<R> groupedByTime(long time,
 java.util.concurrent.TimeUnit unit,
 java.util.function.Supplier<C> factory,
 java.util.function.Function<? super C,? extends R> finalizer)
```
 Specified by:
 
 groupedByTime in interface ReactiveSeq<T>
 - 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(CyclopsCollectors.toList()).size(),is(1));
 assertThat(ReactiveSeq.of(1,2,3,4,5,6).batchByTime(1,TimeUnit.NANOSECONDS).collect(CyclopsCollectors.toList()).size(),greaterThan(5));
 
 
```
 Specified by:
 
 groupedByTime in interface ReactiveSeq<T>
 
 Parameters:
 
 time - - time period to build a singleUnsafe batch in
 
 t - time unit for batch
 
 Returns:
 
 ReactiveSeq batched into lists by time period
 - 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 toX 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 singleUnsafe batch in
 
 unit - time unit for batch
 
 factory - Collection factory
 
 Returns:
 
 ReactiveSeq batched into toX types by time period
 - grouped
```
public <C extends java.util.Collection<? super T>> ReactiveSeq<C> grouped(int size,
 java.util.function.Supplier<C> supplier)
```
 Description copied from interface: ReactiveSeq
 Batch elements in a Stream by size into a toX 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 Traversable<T>
 
 Specified by:
 
 grouped in interface ReactiveSeq<T>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 ReactiveSeq batched into toX types by size
 - 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 Traversable<T>
 
 Specified by:
 
 groupedWhile in interface ReactiveSeq<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, applyHKT 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 Traversable<T>
 
 Specified by:
 
 groupedWhile in interface ReactiveSeq<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, applyHKT open next batch
 
 factory - Collection factory
 
 Returns:
 
 ReactiveSeq batched into collections determined by the predicate supplied
 - distinct
```
public ReactiveSeq<T> distinct()
```
 Specified by:
 
 distinct in interface Traversable<T>
 
 Specified by:
 
 distinct in interface ReactiveSeq<T>
 
 Specified by:
 
 distinct in interface java.util.stream.Stream<T>
 - scanLeft
```
public  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 Traversable<T>
 
 Specified by:
 
 scanLeft in interface ReactiveSeq<T>
 - sorted
```
public 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 Traversable<T>
 
 Specified by:
 
 sorted in interface ReactiveSeq<T>
 
 Specified by:
 
 sorted in interface java.util.stream.Stream<T>
 - skip
```
public 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 Traversable<T>
 
 Specified by:
 
 skip in interface ReactiveSeq<T>
 
 Specified by:
 
 skip in interface java.util.stream.Stream<T>
 
 Parameters:
 
 num - Number of elemenets to skip
 
 Returns:
 
 Stream with specified number of elements skipped
 - forEach
```
public void forEach(java.util.function.Consumer<? super T> action)
```
 Description copied from interface: ReactiveSeq
 
 Performs an action for each element of this Stream. For potentially non-blocking analogs see ReactiveSeq.forEachAsync(Consumer) and forEach overloads such as FoldableTraversable.forEach(Consumer, Consumer) and FoldableTraversable.forEach(Consumer, Consumer,Runnable) This method overrides the JDK Stream.forEach(Consumer) and maintains it's blocking semantics. Other forEach overloads in ReactiveSeq are non-blocking for asynchronously executing Streams.
 
 This is a terminal operation.
 
 The behavior of this operation is explicitly nondeterministic. For parallel reactiveStream pipelines, this operation does not guarantee to respect the encounter order of the reactiveStream, as doing so would sacrifice the benefit of parallelism. For any given element, the action may be performed at whatever time and in whatever thread the library chooses. If the action accesses shared state, it is responsible for providing the required synchronization.
 
 Specified by:
 
 forEach in interface ReactiveSeq<T>
 
 Specified by:
 
 forEach in interface java.lang.Iterable<T>
 
 Specified by:
 
 forEach in interface java.util.stream.Stream<T>
 
 Parameters:
 
 action - a non-interfering action to perform on the elements
 - 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>
 - skipWhile
```
public 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 Traversable<T>
 
 Specified by:
 
 skipWhile in interface ReactiveSeq<T>
 
 Parameters:
 
 p - Predicate to skip while true
 
 Returns:
 
 Stream with elements skipped while predicate holds
 - limit
```
public 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 Traversable<T>
 
 Specified by:
 
 limit in interface ReactiveSeq<T>
 
 Specified by:
 
 limit in interface java.util.stream.Stream<T>
 
 Parameters:
 
 num - Limit element size to num
 
 Returns:
 
 Monad converted to Stream with elements up to num
 - limitWhile
```
public 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 Traversable<T>
 
 Specified by:
 
 limitWhile in interface ReactiveSeq<T>
 
 Parameters:
 
 p - Limit while predicate is true
 
 Returns:
 
 Stream with limited elements
 - limitWhileClosed
```
public ReactiveSeq<T> limitWhileClosed(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 limitWhileClosed in interface ReactiveSeq<T>
 - limitUntil
```
public 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 Traversable<T>
 
 Specified by:
 
 limitUntil in interface ReactiveSeq<T>
 
 Parameters:
 
 p - Limit until predicate is true
 
 Returns:
 
 Stream with limited elements
 - limitUntilClosed
```
public ReactiveSeq<T> limitUntilClosed(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 limitUntilClosed in interface ReactiveSeq<T>
 - parallel
```
public 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>>
 
 Returns:
 
 Does nothing ReactiveSeq is for Sequential Streams
 - allMatch
```
public 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 CyclopsCollectable<T>
 
 Specified by:
 
 allMatch in interface ReactiveSeq<T>
 
 Specified by:
 
 allMatch in interface java.util.stream.Stream<T>
 
 Parameters:
 
 c - Predicate to check if all match
 - anyMatch
```
public boolean anyMatch(java.util.function.Predicate<? super T> c)
```
 Description copied from interface: ReactiveSeq
 True if a singleUnsafe 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 CyclopsCollectable<T>
 
 Specified by:
 
 anyMatch in interface ReactiveSeq<T>
 
 Specified by:
 
 anyMatch in interface java.util.stream.Stream<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 Folds<T>
 
 Specified by:
 
 xMatch in interface ReactiveSeq<T>
 - noneMatch
```
public boolean noneMatch(java.util.function.Predicate<? super T> c)
```
 Specified by:
 
 noneMatch in interface CyclopsCollectable<T>
 
 Specified by:
 
 noneMatch in interface ReactiveSeq<T>
 
 Specified by:
 
 noneMatch in interface java.util.stream.Stream<T>
 - join
```
public java.lang.String join()
```
 Description copied from interface: ReactiveSeq
```
 
 assertEquals("123".length(),ReactiveSeq.of(1, 2, 3).join().length());
 
 
```
 Specified by:
 
 join in interface Folds<T>
 
 Specified by:
 
 join in interface ReactiveSeq<T>
 
 Returns:
 
 Stream as concatenated String
 - join
```
public 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 Folds<T>
 
 Specified by:
 
 join in interface ReactiveSeq<T>
 
 Returns:
 
 Stream as concatenated String
 - join
```
public 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 Folds<T>
 
 Specified by:
 
 join in interface ReactiveSeq<T>
 
 Returns:
 
 Stream as concatenated String
 - headAndTail
```
public HeadAndTail<T> headAndTail()
```
 Description copied from interface: FoldableTraversable
 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 FoldableTraversable<T>
 
 Specified by:
 
 headAndTail in interface ReactiveSeq<T>
 
 Returns:
 - findFirst
```
public java.util.Optional<T> findFirst()
```
 Specified by:
 
 findFirst in interface Folds<T>
 
 Specified by:
 
 findFirst in interface ReactiveSeq<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)
 - findOne
```
public Maybe<T> findOne()
```
 Description copied from interface: ReactiveSeq
 
 Lazy / reactiveBuffer analogue of findFirst / findAny from JDK For push based reactiveBuffer-streams (created via Spouts.XXX) data will be pushed to the returned Maybe on arrival. For pull based Streams (created via ReactiveSeq.XXX) the Stream will be executed when the Maybe is first accessed.
 
 Specified by:
 
 findOne in interface ReactiveSeq<T>
 
 Returns:
 - findFirstOrError
```
public Either<java.lang.Throwable,T> findFirstOrError()
```
 Description copied from interface: ReactiveSeq
 
 Lazy / reactiveBuffer look up of first value , capturing the first error, if one occurs. If no values are present a NoSuchElementException is returned. For push based reactiveBuffer-streams (created via Spouts.XXX) data will be pushed to the returned Either on arrival. For pull based Streams (created via ReactiveSeq.XXX) the Stream will be executed when the Either is first accessed.
 
 Specified by:
 
 findFirstOrError in interface ReactiveSeq<T>
 
 Returns:
 - findAny
```
public java.util.Optional<T> findAny()
```
 Specified by:
 
 findAny in interface Folds<T>
 
 Specified by:
 
 findAny in interface ReactiveSeq<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 <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 Folds<T>
 
 Specified by:
 
 mapReduce in interface ReactiveSeq<T>
 
 Parameters:
 
 reducer - Monoid to reduce values
 
 Returns:
 
 Reduce result
 - mapReduce
```
public <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 Folds<T>
 
 Specified by:
 
 mapReduce in interface ReactiveSeq<T>
 
 Parameters:
 
 mapper - Function to map Monad type
 
 reducer - Monoid to reduce values
 
 Returns:
 
 Reduce result
 - reduce
```
public 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 Folds<T>
 
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Parameters:
 
 reducer - Use supplied Monoid to reduce values
 
 Returns:
 
 reduced values
 - reduce
```
public java.util.Optional<T> reduce(java.util.function.BinaryOperator<T> accumulator)
```
 Description copied from interface: Folds
 An equivalent function to Stream.reduce(BinaryOperator)
```
 
 
 ReactiveSeq.of(1,2,3,4,5).map(it -> it*100).reduce(
 (acc,next) -> acc+next)
 //Optional[1500]
 
 
```
 Specified by:
 
 reduce in interface Folds<T>
 
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Specified by:
 
 reduce in interface java.util.stream.Stream<T>
 
 Parameters:
 
 accumulator - Combiner function
 
 Returns:
 - reduce
```
public T reduce(T identity,
 java.util.function.BinaryOperator<T> accumulator)
```
 Description copied from interface: Folds
 
 An equivalent function to Stream.reduce(Object, BinaryOperator)
 
 Specified by:
 
 reduce in interface Folds<T>
 
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Specified by:
 
 reduce in interface java.util.stream.Stream<T>
 
 accumulator - Combiner function
 
 Returns:
 
 Value emitted by applying the current accumulated value and the next value to the combiner function as this Folds is traversed from left to right
 - reduce
```
public  U reduce(U identity,
 java.util.function.BiFunction<U,? super T,U> accumulator,
 java.util.function.BinaryOperator combiner)
```
 Description copied from interface: Folds
 
 An equivalent function to Stream.reduce(Object, BiFunction, BinaryOperator)
 
 Specified by:
 
 reduce in interface Folds<T>
 
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Specified by:
 
 reduce in interface java.util.stream.Stream<T>
 - reduce
```
public 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).reactiveStream());

 assertThat(result, equalTo(Arrays.asList(10, 24)));

 
 
```
 Specified by:
 
 reduce in interface Folds<T>
 
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Returns:
 
 List of reduced values
 - reduce
```
public 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 Folds<T>
 
 Specified by:
 
 reduce in interface ReactiveSeq<T>
 
 Returns:
 - foldRight
```
public T foldRight(Monoid<T> reducer)
```
 Description copied from interface: ReactiveSeq
```
 
 		ReactiveSeq.of("a","b","c").foldRight(Reducers.toString(""));

 // "cab"
 
 
```
 Specified by:
 
 foldRight in interface Folds<T>
 
 Specified by:
 
 foldRight in interface ReactiveSeq<T>
 
 Parameters:
 
 reducer - Use supplied Monoid to reduce values starting via foldRight
 
 Returns:
 
 Reduced result
 - 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 Folds<T>
 
 Specified by:
 
 foldRight in interface ReactiveSeq<T>
 
 Parameters:
 
 identity - Identity value for the combiner function (leaves the input unchanged)
 
 accumulator - Combining function
 
 Returns:
 
 Reduced value
 - foldRightMapToType
```
public <T1> T1 foldRightMapToType(Reducer<T1> 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 Folds<T>
 
 Specified by:
 
 foldRightMapToType in interface ReactiveSeq<T>
 
 Parameters:
 
 reducer - Monoid to reduce values
 
 Returns:
 
 Reduce result
 - stream
```
public ReactiveSeq<T> stream()
```
 Description copied from interface: ReactiveSeq
 
 Convert this ReactiveSeq into a Stream
 
 Specified by:
 
 stream in interface Folds<T>
 
 Specified by:
 
 stream in interface TransformerTraversable<T>
 
 Specified by:
 
 stream in interface ExtendedTraversable<T>
 
 Specified by:
 
 stream in interface FoldableTraversable<T>
 
 Specified by:
 
 stream in interface Sequential<T>
 
 Specified by:
 
 stream in interface Traversable<T>
 
 Specified by:
 
 stream in interface ReactiveSeq<T>
 
 Returns:
 
 This Traversable converted to a Stream
 - unitIterator
```
public  Traversable unitIterator(java.util.Iterator U)
```
 Description copied from interface: Traversable
 Create an IterableFunctor instance of the same type from an Iterator
```
 
 ReactiveSeq<Integer> newSeq = seq.unitIterable(myIterator);

 
 
```
 Specified by:
 
 unitIterator in interface Traversable<T>
 
 Parameters:
 
 U - Iterator to create new IterableFunctor from
 
 Returns:
 
 New IterableFunctor instance
 - startsWithIterable
```
public 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 Folds<T>
 
 Specified by:
 
 startsWithIterable in interface ReactiveSeq<T>
 
 Returns:
 
 True if Monad starts with Iterable sequence of data
 - startsWith
```
public boolean startsWith(java.util.stream.Stream<T> stream)
```
 Description copied from interface: ReactiveSeq
```
 assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Stream.of(1,2,3))) 
 
```
 Specified by:
 
 startsWith in interface Folds<T>
 
 Specified by:
 
 startsWith in interface ReactiveSeq<T>
 
 Parameters:
 
 stream - Stream to check if this Folds has the same elements in the same order, at the skip
 
 Returns:
 
 True if Monad starts with Iterators sequence of data
 - anyM
```
public AnyMSeq<Witness.reactiveSeq,T> anyM()
```
 Specified by:
 
 anyM in interface ReactiveSeq<T>
 
 Returns:
 
 this ReactiveSeq converted to AnyM format
 - map
```
public <R> ReactiveSeq<R> map(java.util.function.Function<? super T,? extends R> fn)
```
 Description copied from interface: Transformable
 Transform this functor using the supplied transformation function
```
 


 of(1,2,3).map(i->i*2)

 //[2,4,6]

 
 
```
 Specified by:
 
 map in interface FilterableTransformable<T>
 
 Specified by:
 
 map in interface Transformable<T>
 
 Specified by:
 
 map in interface ReactiveSeq<T>
 
 Specified by:
 
 map in interface java.util.stream.Stream<T>
 
 Parameters:
 
 fn - Transformation function
 
 Returns:
 
 Transformed Transformable
 - flatMap
```
public <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).reactiveStream())
 						.toList(),equalTo(asList(1, -1, 2, -2)));

 
 
```
 Specified by:
 
 flatMap in interface ReactiveSeq<T>
 
 Specified by:
 
 flatMap in interface java.util.stream.Stream<T>
 
 Parameters:
 
 fn - to be applied
 
 Returns:
 
 new stage in Sequence with flatMap operation to be lazily applied
 - 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>
 - 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>
 - 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>
 - flatMapAnyM
```
public <R> ReactiveSeq<R> flatMapAnyM(java.util.function.Function<? super T,AnyM<Witness.stream,? 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-> fromEither5(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
 - flatMapI
```
public <R> ReactiveSeq<R> flatMapI(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:
 
 flatMapI in interface ReactiveSeq<T>
 
 Returns:
 - flatMapP
```
public <R> ReactiveSeq<R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
 Specified by:
 
 flatMapP in interface ReactiveSeq<T>
 - flatMapP
```
public <R> ReactiveSeq<R> flatMapP(int maxConcurrency,
 java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
 Specified by:
 
 flatMapP in interface ReactiveSeq<T>
 - flatMapStream
```
public <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
 - filter
```
public ReactiveSeq<T> filter(java.util.function.Predicate<? super T> fn)
```
 Description copied from interface: Filters
 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 Filters<T>
 
 Specified by:
 
 filter in interface FilterableTransformable<T>
 
 Specified by:
 
 filter in interface ReactiveSeq<T>
 
 Specified by:
 
 filter in interface java.util.stream.Stream<T>
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - 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()
```
 Description copied from interface: ReactiveSeq
 
 Returns a spliterator for the elements of this reactiveStream.
 
 This is a terminal operation.
 
 Specified by:
 
 spliterator in interface ReactiveSeq<T>
 
 Specified by:
 
 spliterator in interface java.lang.Iterable<T>
 
 Specified by:
 
 spliterator in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
 
 Returns:
 
 the element spliterator for this reactiveStream
 - 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>>
 - 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>>
 - 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 Traversable<T>
 
 Specified by:
 
 reverse in interface ReactiveSeq<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>>
 - 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>>
 - prependS
```
public ReactiveSeq<T> prependS(java.util.stream.Stream<? extends T> stream)
```
 Description copied from interface: ReactiveSeq
 Prepend Stream to this ReactiveSeq
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3)
 .prependS(of(100, 200, 300))
 .map(it -> it + "!!")
 .collect(CyclopsCollectors.toList());

 assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
 
 
```
 Specified by:
 
 prependS in interface Traversable<T>
 
 Specified by:
 
 prependS 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 take of this ReactiveSeq
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3).append(100, 200, 300).map(it -> it + "!!").collect(CyclopsCollectors.toList());

 assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!"))); * 
 
```
 Specified by:
 
 append in interface Traversable<T>
 
 Specified by:
 
 append in interface ReactiveSeq<T>
 
 Parameters:
 
 values - to append
 
 Returns:
 
 ReactiveSeq with appended values
 - append
```
public ReactiveSeq<T> append(T value)
```
 Specified by:
 
 append in interface Traversable<T>
 
 Specified by:
 
 append in interface ReactiveSeq<T>
 - prepend
```
public ReactiveSeq<T> prepend(T value)
```
 Specified by:
 
 prepend in interface Traversable<T>
 
 Specified by:
 
 prepend in interface ReactiveSeq<T>
 - prepend
```
public ReactiveSeq<T> prepend(T... values)
```
 Description copied from interface: ReactiveSeq
 Prepend given values to the skip of the Stream
```
 
 List<String> result = 	ReactiveSeq.of(1,2,3)
 									 .prepend(100,200,300)
 										 .map(it ->it+"!!")
 										 .collect(CyclopsCollectors.toList());

 			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 
```
 Specified by:
 
 prepend in interface Traversable<T>
 
 Specified by:
 
 prepend in interface ReactiveSeq<T>
 
 Parameters:
 
 values - to prepend
 
 Returns:
 
 ReactiveSeq with values prepended
 - 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 Folds<T>
 
 Specified by:
 
 endsWithIterable in interface ReactiveSeq<T>
 
 Parameters:
 
 iterable - Values to check
 
 Returns:
 
 true if ReactiveSeq ends with values in the supplied iterable
 - endsWith
```
public boolean endsWith(java.util.stream.Stream<T> stream)
```
 Description copied from interface: ReactiveSeq
```
 
 assertTrue(ReactiveSeq.of(1,2,3,4,5,6)
 				.endsWith(Stream.of(5,6)));
 
 
```
 Specified by:
 
 endsWith in interface Folds<T>
 
 Specified by:
 
 endsWith in interface ReactiveSeq<T>
 
 Parameters:
 
 stream - 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
 - skipLast
```
public ReactiveSeq<T> skipLast(int num)
```
 Description copied from interface: ReactiveSeq
 
 assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
 
 Specified by:
 
 skipLast in interface Traversable<T>
 
 Specified by:
 
 skipLast in interface ReactiveSeq<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(CyclopsCollectors.toList()),equalTo(Arrays.asList(4,5)));

 
```
 Specified by:
 
 limitLast in interface Traversable<T>
 
 Specified by:
 
 limitLast in interface ReactiveSeq<T>
 
 Parameters:
 
 num - of elements to return (last elements)
 
 Returns:
 
 ReactiveSeq limited to last num elements
 - 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 Folds<T>
 
 Specified by:
 
 firstValue in interface ReactiveSeq<T>
 
 Returns:
 
 first value in this Stream
 - onEmptySwitch
```
public ReactiveSeq<T> onEmptySwitch(java.util.function.Supplier<? extends java.util.stream.Stream<T>> switchTo)
```
 Description copied from interface: ReactiveSeq
 If this ReactiveSeq is empty one it with a another Stream
```
 
 assertThat(ReactiveSeq.of(4,5,6)
 							.onEmptySwitch(()->ReactiveSeq.of(1,2,3))
 							.toList(),
 							equalTo(Arrays.asList(4,5,6)));
 
 
```
 Specified by:
 
 onEmptySwitch in interface OnEmptySwitch<T,java.util.stream.Stream<T>>
 
 Specified by:
 
 onEmptySwitch in interface ReactiveSeq<T>
 
 Parameters:
 
 switchTo - Supplier that will generate the alternative Stream
 
 Returns:
 
 ReactiveSeq that will switch to an alternative Stream if empty
 - onEmptyGet
```
public ReactiveSeq<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is zero, create a new instance containing the value returned from the provided Supplier
 
 Specified by:
 
 onEmptyGet in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 
 Specified by:
 
 onEmptyGet in interface ReactiveSeq<T>
 
 Parameters:
 
 supplier - to determine new value for container
 
 Returns:
 
 New Container with value if this is zero, 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 zero, throw the exception returned by the provided Supplier
 
 Specified by:
 
 onEmptyThrow in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyThrow in interface Traversable<T>
 
 Specified by:
 
 onEmptyThrow in interface ReactiveSeq<T>
 
 Parameters:
 
 supplier - to create exception from
 
 Returns:
 
 Throw exception if zero, otherwise this container
 - distinct
```
public  ReactiveSeq<T> distinct(java.util.function.Function<? super T,? extends U> keyExtractor)
```
 Specified by:
 
 distinct in interface ReactiveSeq<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(CyclopsCollectors.toList())
 .size();
 //6

 
 
```
 Specified by:
 
 xPer in interface Sequential<T>
 
 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::reactiveStream)
 				.peek(individual -> System.out.println("Flattened : "
 						+ individual))
 				.forEach(a->{});
 
```
 Specified by:
 
 onePer in interface Sequential<T>
 
 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 applyHKT debouncing over
 
 t - Time unit for debounce period
 
 Returns:
 
 ReactiveSeq with debouncing applied
 - 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(CyclopsCollectors.toList())
 .size();
 //6
 	assertThat(timer.getElapsedNanoseconds(), greaterThan(60000l));
 
 
```
 Specified by:
 
 fixedDelay in interface Sequential<T>
 
 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 maxJitterPeriodInNanos)
```
 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(CyclopsCollectors.toList());

 assertThat(timer.getElapsedNanoseconds(), greaterThan(20000l));
 }
 
```
 Specified by:
 
 jitter in interface ReactiveSeq<T>
 
 Parameters:
 
 maxJitterPeriodInNanos - - random number less than this is used for each jitter
 
 Returns:
 
 ReactiveSeq with a random jitter between element emission
 - complete
```
public ReactiveSeq<T> complete(java.lang.Runnable fn)
```
 Description copied from interface: ReactiveSeq
 
 Provide a simpler method to handle stream or async operations.
 
 Specified by:
 
 complete in interface ReactiveSeq<T>
 
 Parameters:
 
 fn - Function that accepts and returns completed value
 
 Returns:
 
 ReactiveSeq that can handle stream or async operations simpler
 - recover
```
public ReactiveSeq<T> recover(java.util.function.Function<? super 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 Traversable<T>
 
 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<? super 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 Traversable<T>
 
 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
 - count
```
public long count()
```
 Description copied from interface: ReactiveSeq
 Returns the count of elements in this reactiveStream. This is a special case of a reduction and is equivalent to:
```
 return mapToLong(e -> 1L).sum();
 
```
 This is a terminal operation.
 Specified by:
 
 count in interface CyclopsCollectable<T>
 
 Specified by:
 
 count in interface ReactiveSeq<T>
 
 Specified by:
 
 count in interface java.util.stream.Stream<T>
 
 Returns:
 
 the count of elements in this reactiveStream
 - appendS
```
public ReactiveSeq<T> appendS(java.util.stream.Stream<? extends T> other)
```
 Description copied from interface: ReactiveSeq
 Append Stream to this ReactiveSeq
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3).appendStream(ReactiveSeq.of(100, 200, 300)).map(it -> it + "!!").collect(CyclopsCollectors.toList());

 assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!"))); * 
 
```
 Specified by:
 
 appendS in interface ReactiveSeq<T>
 
 Returns:
 
 ReactiveSeq with Stream appended
 - append
```
public ReactiveSeq<T> append(java.lang.Iterable<? extends T> other)
```
 Specified by:
 
 append in interface ReactiveSeq<T>
 - prepend
```
public ReactiveSeq<T> prepend(java.lang.Iterable<? extends T> other)
```
 Specified by:
 
 prepend in interface ReactiveSeq<T>
 - cycle
```
public ReactiveSeq<T> cycle(long times)
```
 Description copied from interface: ReactiveSeq
 Convert to a Stream with the values repeated specified times
```
 
 		ReactiveSeq.of(1,2,2)
 								.cycle(3)
 								.collect(CyclopsCollectors.toList());

 		//List[1,2,2,1,2,2,1,2,2]

 
 
```
 Specified by:
 
 cycle in interface Traversable<T>
 
 Specified by:
 
 cycle in interface ReactiveSeq<T>
 
 Parameters:
 
 times - Times values should be repeated within a Stream
 
 Returns:
 
 Stream with values repeated
 - skipWhileClosed
```
public ReactiveSeq<T> skipWhileClosed(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 skipWhileClosed in interface ReactiveSeq<T>
 - format
```
public java.lang.String format()
```
 Specified by:
 
 format in interface ReactiveSeq<T>
 - changes
```
public ReactiveSeq<T> changes()
```
 Specified by:
 
 changes in interface ReactiveSeq<T>
 
 Returns:
 
 A Stream that contains only changes in the values in the current Stream, useful for converting a Continuous sequence into one with discrete steps
 - forEachSubscribe
```
public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachSubscribe(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 = Spouts.of(1,2,3,4)
 					 .forEachSubscribe(System.out::println);

 next.request(2);
 Thread.sleep(500);
 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:
 
 forEachSubscribe in interface ReactiveStreamsTerminalOperations<T>
 
 Specified by:
 
 forEachSubscribe in interface FoldableTraversable<T>
 
 Parameters:
 
 consumer - To accept incoming events from the Stream
 
 Returns:
 
 Subscription so that further processing can be continued or cancelled.
 - forEachSubscribe
```
public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachSubscribe(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)
 					 .forEachSubscribe(System.out::println, e->e.printStackTrace());

 next.request(2);
 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:
 
 forEachSubscribe in interface ReactiveStreamsTerminalOperations<T>
 
 Specified by:
 
 forEachSubscribe in interface FoldableTraversable<T>
 
 Parameters:
 
 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.
 - forEachSubscribe
```
public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachSubscribe(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)
 					 .forEachSubscribe(System.out::println, e->e.printStackTrace(),()->System.out.println("the take!"));

 next.request(2);
 System.out.println("First batch processed!");

 next.request(2);

 System.out.println("Second batch processed!");

 //prints
 1
 2
 First batch processed!

 RuntimeException Stack Trace on System.err

 4
 Second batch processed!
 The take!
 
 
```
 Specified by:
 
 forEachSubscribe in interface ReactiveStreamsTerminalOperations<T>
 
 Specified by:
 
 forEachSubscribe in interface FoldableTraversable<T>
 
 Parameters:
 
 consumer - To accept incoming elements from the Stream
 
 consumerError - To accept incoming processing errors from the Stream
 
 onComplete - To run after an onComplete event
 
 Returns:
 
 Subscription so that further processing can be continued or cancelled.
 - collect
```
public <R> R collect(java.util.function.Supplier<R> supplier,
 java.util.function.BiConsumer<R,? super T> accumulator,
 java.util.function.BiConsumer<R,R> combiner)
```
 Description copied from interface: ReactiveSeq
 Performs a mutable reduction operation on the elements of this reactiveStream. A mutable reduction is one in which the reduced value is a mutable result container, such as an ArrayList, and elements are incorporated by updating the state of the result rather than by replacing the result. This produces a result equivalent to:
```
 R result = supplier.get();
 for (T element : this reactiveStream)
 accumulator.accept(result, element);
 return result;
 
```
 Like ReactiveSeq.reduce(Object, BinaryOperator), collect operations can be parallelized without requiring additional synchronization.
 
 This is a terminal operation.
 Specified by:
 
 collect in interface ReactiveSeq<T>
 
 Specified by:
 
 collect in interface java.util.stream.Stream<T>
 
 Parameters:
 
 supplier - a function that creates a new result container. For a parallel execution, this function may be called multiple times and must return a fresh value each time.
 
 accumulator - an associative, non-interfering, stateless function for incorporating an additional element into a result
 
 combiner - an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function
 
 Returns:
 
 the result of the reduction
 - collectStream
```
public <R,A> ReactiveSeq<R> collectStream(java.util.stream.Collector<? super T,A,R> collector)
```
 Specified by:
 
 collectStream in interface ReactiveSeq<T>
 - collect
```
public <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
```
 Description copied from interface: ReactiveSeq
 
 Performs a mutable reduction operation on the elements of this reactiveStream using a Collector. A Collector encapsulates the function used as arguments to ReactiveSeq.collect(Supplier, BiConsumer, BiConsumer), allowing for reuse of toX strategies and composition of collect operations such as multiple-level grouping or partitioning.
 
 If the reactiveStream is parallel, and the Collector is concurrent, and lazy the reactiveStream is unordered or the collector is unordered, applyHKT a concurrent reduction will be performed (see Collector for details on concurrent reduction.)
 
 This is a terminal operation.
 
 When executed in parallel, multiple intermediate results may be instantiated, populated, and merged so as to maintain isolation of mutable data structures. Therefore, even when executed in parallel with non-thread-safe data structures (such as ArrayList), no additional synchronization is needed for a parallel reduction.
 
 Specified by:
 
 collect in interface CyclopsCollectable<T>
 
 Specified by:
 
 collect in interface ReactiveSeq<T>
 
 Specified by:
 
 collect in interface java.util.stream.Stream<T>
 
 Parameters:
 
 collector - the Collector describing the reduction
 
 Returns:
 
 the result of the reduction
 
 See Also:
 
 ReactiveSeq.collect(Supplier, BiConsumer, BiConsumer), Collectors
 - forEachAsync
```
public void forEachAsync(java.util.function.Consumer<? super T> action)
```
 Description copied from interface: ReactiveSeq
 
 A potentially non-blocking analog of ReactiveSeq.forEach(java.util.function.Consumer<? super T>). For push based reactiveBuffer Stream types (created via Spouts or FutureStream)
 
 Specified by:
 
 forEachAsync in interface ReactiveSeq<T>
 
 Parameters:
 
 action - a non-interfering action to perform on the elements
 - singleUnsafe
```
public T singleUnsafe()
```
 Description copied from interface: ReactiveSeq
```
 

 //1
 ReactiveSeq.of(1).singleUsafe();

 //UnsupportedOperationException
 ReactiveSeq.of().singleUnsafe();

 //UnsupportedOperationException
 ReactiveSeq.of(1,2,3).singleUnsafe();
 
 
```
 Specified by:
 
 singleUnsafe in interface Folds<T>
 
 Specified by:
 
 singleUnsafe in interface ReactiveSeq<T>
 
 Returns:
 
 a singleUnsafe value or an UnsupportedOperationException if 0/1 values in this Stream
 - single
```
public Maybe<T> single(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 single in interface Folds<T>
 
 Specified by:
 
 single in interface ReactiveSeq<T>
 - single
```
public Maybe<T> single()
```
 Description copied from interface: ReactiveSeq
```
 

 //Maybe[1]
 ReactiveSeq.of(1).singleUnsafe();

 //Maybe.none
 ReactiveSeq.of().singleUnsafe();

 //Maybe.none
 ReactiveSeq.of(1,2,3).singleUnsafe();
 
 
```
 Specified by:
 
 single in interface Folds<T>
 
 Specified by:
 
 single in interface ReactiveSeq<T>
 
 Returns:
 
 An Maybe with singleUnsafe value if this Stream has exactly one element, otherwise Maybe.none
 - subscribe
```
public void subscribe(org.reactivestreams.Subscriber<? super T> s)
```
 Specified by:
 
 subscribe in interface Traversable<T>
 
 Specified by:
 
 subscribe in interface org.reactivestreams.Publisher<T>
 - visit
```
public <R> R visit(java.util.function.Function<? super ReactiveSeq<T>,? extends R> sync,
 java.util.function.Function<? super ReactiveSeq<T>,? extends R> reactiveStreams,
 java.util.function.Function<? super ReactiveSeq<T>,? extends R> asyncNoBackPressure)
```
 Specified by:
 
 visit in interface ReactiveSeq<T>
 - groupedT
```
public ListT<Witness.reactiveSeq,T> groupedT(int groupSize)
```
 Description copied from interface: TransformerTraversable
 Group the elements in this Traversable into batches of the provided size. A List Transformer view into the data will be provided, ListTransformers allow nested Lists to be manipulated directly. The data will remain nested (as List's inside the current Traversable), but the ListTransformer will be able to operate aggregate operations across all nested Lists, each operation on the List Transformer is applied, by the transformer to all Lists.
```
 
 ListTSeq<Integer> transformer = ReactiveSeq.of(2,1,3,4,5,7,6,8,9,10)
 .groupedT(4);
 
 //ReactiveSeq[List[2,1,3,4],List[5,7,6,8],List[9,10]]
 
 ListTSeq<ListX<Integer>> nested = transformer.map(i->i*2)
 .sorted()
 .grouped(2); 
 
 //ReactiveSeq[List[List[2,4],List[6,8]],List[List[10,14],List[12,16]],List[List[18,20]]]
 
 
```
 Specified by:
 
 groupedT in interface TransformerTraversable<T>
 
 Parameters:
 
 groupSize - Size of each batch of elements to be grouped into Lists
 
 Returns:
 
 List Transformer view into batched / grouped data
 - slidingT
```
public ListT<Witness.reactiveSeq,T> slidingT(int windowSize,
 int increment)
```
 Description copied from interface: TransformerTraversable
 Create a Sliding window into the data in this traversble. A List Transformer view into the data will be provided, ListTransformers allow nested Lists to be manipulated directly. The data will remain nested (as List's inside the current Traversable), but the ListTransformer will be able to operate aggregate operations across all nested Lists, each operation on the List Transformer is applied, by the transformer to all Lists.
```
 
 ListTSeq<Integer> sliding = ListX.of(1,2,3,4,5,6,7)
 .sliding(3,2);
 
 //ReactiveSeq[List[1,2,3],List[3,4,5],List[5,6,7],List[7]]
 
 
```
 Specified by:
 
 slidingT in interface TransformerTraversable<T>
 
 Parameters:
 
 windowSize - Size of sliding window
 
 increment - Increment between windows
 
 Returns:
 
 List Transformer view into the Sliding windows
 - slidingT
```
public ListT<Witness.reactiveSeq,T> slidingT(int windowSize)
```
 Description copied from interface: TransformerTraversable
 Create a Sliding window into the data in this traversble. A List Transformer view into the data will be provided, ListTransformers allow nested Lists to be manipulated directly. The data will remain nested (as List's inside the current Traversable), but the ListTransformer will be able to operate aggregate operations across all nested Lists, each operation on the List Transformer is applied, by the transformer to all Lists. ( @see TransformerTraversable#grouped(int) )
```
 
 ListTSeq<Integer> sliding = ListX.of(1,2,3,4,5,6,7)
 .sliding(3);
 
 //ReactiveSeq[List[1,2,3],List[2,3,4],List[4,5,6],List[6,7]]
 
 
```
 Specified by:
 
 slidingT in interface TransformerTraversable<T>
 
 Parameters:
 
 windowSize - Size of sliding window
 
 Returns:
 
 List Transformer view into the Sliding windows
 - groupedUntilT
```
public ListT<Witness.reactiveSeq,T> groupedUntilT(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: TransformerTraversable
 Create a Traversable batched by List, where each batch is populated until the predicate holds. A List Transformer view into the data will be provided, ListTransformers allow nested Lists to be manipulated directly. The data will remain nested (as List's inside the current Traversable), but the ListTransformer will be able to operate aggregate operations across all nested Lists, each operation on the List Transformer is applied, by the transformer to all Lists.
```
 
 ListTSeq<Integer> grouped = ReactiveSeq.of(1,2,3,4,5,6)
 .groupedWhile(i->i%3!=0)
 .toList();
 
 //ReactiveSeq[List[1,2,3],List[4,5,6]] 
 
 
 
```
 Specified by:
 
 groupedUntilT in interface TransformerTraversable<T>
 
 Parameters:
 
 predicate - Predicate to determine batch termination point
 
 Returns:
 
 List Transformer view into batched Traversable
 - groupedStatefullyUntilT
```
public ListT<Witness.reactiveSeq,T> groupedStatefullyUntilT(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
```
 Description copied from interface: TransformerTraversable
 
 List Transformer view into batched Lists where each List is populated while the supplied bipredicate holds. The bipredicate recieves the List from the last window as well as the current value and can choose to aggregate the current value or create a new window
 
 Specified by:
 
 groupedStatefullyUntilT in interface TransformerTraversable<T>
 
 Parameters:
 
 predicate - Predicate to determine batch
 
 Returns:
 
 List Transformer view into batched Traversable
 - groupedWhileT
```
public ListT<Witness.reactiveSeq,T> groupedWhileT(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: TransformerTraversable
 Create a Traversable batched by List, where each batch is populated while the predicate holds. A List Transformer view into the data will be provided, ListTransformers allow nested Lists to be manipulated directly. The data will remain nested (as List's inside the current Traversable), but the ListTransformer will be able to operate aggregate operations across all nested Lists, each operation on the List Transformer is applied, by the transformer to all Lists.
```
 
 ListTSeq<Integer> grouped = ReactiveSeq.of(1,2,3,4,5,6,7,8,9,5)
 .groupedUntil(i->i==5)
 .toList();
 
 //ReactiveSeq[List[1,2,3,4,5],List[6,7,8,9,5]] 
 
 
 
```
 Specified by:
 
 groupedWhileT in interface TransformerTraversable<T>
 
 Parameters:
 
 predicate - Predicate to determine batch termination point
 
 Returns:
 
 List Transformer view into batched Traversable

Class FluxReactiveSeq<T>

Nested Class Summary

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

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 cyclops.stream.ReactiveSeq

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

Methods inherited from interface java.util.stream.Stream

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

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

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

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

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

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

Constructor Detail

FluxReactiveSeq

Method Detail

flux

flux

coflatMap

unit

foldRight

zipS

zipLatest

zipP

zipP

cycle

duplicate

duplicate

triplicate

triplicate

quadruplicate

quadruplicate

splitAtHead

splitAt

splitBy

partition

zipS

zip3

zip4

sliding

grouped

groupedStatefullyUntil

groupedStatefullyUntil

groupedStatefullyWhile

groupedStatefullyWhile

groupedBySizeAndTime

groupedBySizeAndTime

groupedBySizeAndTime

groupedByTime

groupedByTime

groupedByTime

grouped

groupedWhile

groupedWhile

distinct

scanLeft

sorted

skip

forEach

forEachOrdered

toArray

toArray

skipWhile

limit

limitWhile

limitWhileClosed

limitUntil

limitUntilClosed

parallel

allMatch

anyMatch

xMatch

noneMatch

join

join

join

headAndTail