CollectionX (cyclops-reactor 9.0.0-FINAL API)

Type Parameters:

T -

All Superinterfaces:

java.util.Collection<T>, CyclopsCollectable<T>, ExtendedTraversable<T>, FilterableTransformable<T>, Filters<T>, FoldableTraversable<T>, Folds<T>, java.lang.Iterable<T>, IterableFilterable<T>, OnEmpty<T>, org.reactivestreams.Publisher<T>, ReactiveStreamsTerminalOperations<T>, Sequential<T>, Transformable<T>, TransformerTraversable<T>, Traversable<T>, Unit<T>, Unwrapable, Zippable<T>

All Known Subinterfaces:

BagX<T>, DequeX<T>, FluentCollectionX<T>, IndexedSequenceX<T>, LazyCollectionX<T>, LazyFluentCollectionX<T>, LinkedListX<T>, ListX<T>, MutableSequenceX<T>, OrderedSetX<T>, PersistentQueueX<T>, PersistentSetX<T>, QueueX<T>, SetX<T>, SortedSetX<T>, VectorX<T>

All Known Implementing Classes:

AbstractLazyCollection, AbstractLazyPersistentCollection, CollectionXImpl, LazyDequeX, LazyLinkedListX, LazyListX, LazyPBagX, LazyPOrderedSetX, LazyPQueueX, LazyPSetX, LazyPVectorX, LazyQueueX, LazySetX, LazySortedSetX
```
public interface CollectionX<T>
extends FoldableTraversable<T>, java.util.Collection<T>, Unwrapable, Unit<T>
```
An interface that extends JDK Collection interface with a significant number of new operators

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <U> CollectionX<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a reactiveStream to a given type, possibly throwing a `ClassCastException`.
`CollectionX<ReactiveSeq<T>>`	`combinations()` Generate the combinations based on values in the ExtendedTraversable.
`CollectionX<ReactiveSeq<T>>`	`combinations(int size)` Generate the combinations based on values in the ExtendedTraversable.
`CollectionX<T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)` Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation.
`CollectionX<T>`	`cycle(long times)` Convert to a Stream with the values repeated specified times
`CollectionX<T>`	`cycle(Monoid<T> m, long times)` Convert to a Stream with the result of a reduction operation repeated specified times
`CollectionX<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`CollectionX<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`CollectionX<T>`	`distinct()`
`default CollectionX<T>`	`drop(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));`
`CollectionX<T>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the take of this Traversable
`CollectionX<T>`	`dropUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`CollectionX<T>`	`dropWhile(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
`CollectionX<T>`	`eager()`
`Evaluation`	`evaluation()`
`CollectionX<T>`	`filter(java.util.function.Predicate<? super T> pred)` Keep only elements for which the supplied predicates hold e.g.
`CollectionX<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`default java.util.Optional<T>`	`findAny()`
`default java.util.Optional<T>`	`findFirst()`
`<R> CollectionX<R>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)` Perform a flatMap operation on this toX.
`<R> CollectionX<R>`	`flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`<R> CollectionX<R>`	`flatMapP(int maxConcurecy, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`default <R> CollectionX<R>`	`flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)`
`default <R1,R> CollectionX<R>`	`forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied reactiveStream
`default <R1,R> CollectionX<R>`	`forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied reactiveStream
`default <R1,R2,R> CollectionX<R>`	`forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`default <R1,R2,R> CollectionX<R>`	`forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`default <R1,R2,R3,R> CollectionX<R>`	`forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`default <R1,R2,R3,R> CollectionX<R>`	`forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3, Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`<T1> CollectionX<T1>`	`from(java.util.Collection<T1> c)` Conctruct an Extended Collection from a standard Collection
`static <T> CollectionX<T>`	`fromCollection(java.util.Collection<T> col)` Create a CollectionX from the supplied Collection
`default Maybe<T>`	`getAtIndex(int index)` Get the element at the specified index (if it exists)
`default <K> MapX<K,ListX<T>>`	`groupBy(java.util.function.Function<? super T,? extends K> classifier)` Use classifier function to group elements in this Sequence into a Map
`<K> CollectionX<org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier)` Group this Traversable by the provided classifying function and collected by the provided Collector
`<K,A,D> CollectionX<org.jooq.lambda.tuple.Tuple2<K,D>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)` Group this Traversable by the provided classifying function and collected by the provided Collector
`CollectionX<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`<C extends java.util.Collection<? super T>> CollectionX<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
`CollectionX<ListX<T>>`	`groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)` Create Travesable of Lists where each List is populated while the supplied bipredicate holds.
`CollectionX<ListX<T>>`	`groupedUntil(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, where each batch is populated until the predicate holds
`<C extends java.util.Collection<? super T>> CollectionX<C>`	`groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
`CollectionX<ListX<T>>`	`groupedWhile(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, where each batch is populated while the predicate holds
`<C extends java.util.Collection<? super T>> CollectionX<C>`	`groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds
`default T`	`head()`
`default HeadAndTail<T>`	`headAndTail()` extract head and tail together, where head is expected to be present Example :
`CollectionX<T>`	`intersperse(T value)` Returns a reactiveStream with a given value interspersed between any two values of this reactiveStream.
`boolean`	`isEager()`
`boolean`	`isEmpty()`
`boolean`	`isLazy()`
`boolean`	`isMaterialized()`
`java.util.Iterator<T>`	`iterator()`
`CollectionX<T>`	`lazy()`
`CollectionX<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`CollectionX<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`CollectionX<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.
`CollectionX<T>`	`limitWhile(java.util.function.Predicate<? super T> p)` Take elements from the Stream while the predicate holds, once the predicate returns false all subsequent elements are excluded
`<R> CollectionX<R>`	`map(java.util.function.Function<? super T,? extends R> mapper)` Transform this functor using the supplied transformation function
`default CollectionX<T>`	`materialize()`
`default CollectionX<T>`	`materializeReversed()`
`CollectionX<T>`	`notNull()` Filter elements retaining only values which are not null
`CollectionX<T>`	`onEmpty(T value)` If this Container instance is zero, create a new instance containing the provided value
`CollectionX<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
`<X extends java.lang.Throwable> CollectionX<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is zero, throw the exception returned by the provided Supplier
`default CollectionX<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Transformable, without transforming it
`CollectionX<ReactiveSeq<T>>`	`permutations()` Generate the permutations based on values in the ExtendedTraversable.
`CollectionX<T>`	`removeAll(T... values)` Remove all supplied elements from this filterable
`CollectionX<T>`	`removeAllI(java.lang.Iterable<? extends T> it)` Remove all elements in the supplied Iterable from this filterable
`CollectionX<T>`	`removeAllS(java.util.stream.Stream<? extends T> stream)` Remove all elements in the supplied Stream from this filterable
`CollectionX<T>`	`retainAll(T... values)` Retain only the supplied elements in the returned Filters
`CollectionX<T>`	`retainAllI(java.lang.Iterable<? extends T> it)` Retain only the supplied elements in the returned Filters
`CollectionX<T>`	`retainAllS(java.util.stream.Stream<? extends T> seq)` Retain only the supplied elements in the returned Filters
`CollectionX<T>`	`reverse()` Potentially efficient Stream reversal.
`CollectionX<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> CollectionX<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`CollectionX<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> CollectionX<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`CollectionX<T>`	`shuffle()`
`CollectionX<T>`	`shuffle(java.util.Random random)`
`default Maybe<T>`	`single()` `//Optional[1] ReactiveSeq.of(1).singleUnsafe(); //Optional.zero ReactiveSeq.of().singleOpional(); //Optional.zero ReactiveSeq.of(1,2,3).singleUnsafe();`
`default Maybe<T>`	`single(java.util.function.Predicate<? super T> predicate)`
`default T`	`singleUnsafe()` `//1 ReactiveSeq.of(1).singleUnsafe(); //UnsupportedOperationException ReactiveSeq.of().singleUnsafe(); //UnsupportedOperationException ReactiveSeq.of(1,2,3).singleUnsafe();`
`CollectionX<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`CollectionX<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
`CollectionX<T>`	`skipUntil(java.util.function.Predicate<? super T> p)` Drop elements from the Stream until the predicate returns true, after which all elements are included
`CollectionX<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 *
`CollectionX<T>`	`slice(long from, long to)`
`CollectionX<VectorX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`CollectionX<VectorX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`CollectionX<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`CollectionX<T>`	`sorted(java.util.Comparator<? super T> c)` `assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));`
`<U extends java.lang.Comparable<? super U>> CollectionX<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`default ReactiveSeq<T>`	`stream()`
`default CollectionX<T>`	`take(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));`
`default Maybe<T>`	`takeOne()`
`CollectionX<T>`	`takeRight(int num)` Generate a new Traversable that takes the specified number elements from the take of this Traversable
`CollectionX<T>`	`takeUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`CollectionX<T>`	`takeWhile(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
`default <R> R`	`toX(java.util.function.Function<? super CollectionX<T>,? extends R> fn)`
`<R> CollectionX<R>`	`trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`<R> CollectionX<R>`	`unit(R r)`
`<U> CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)` Zip (merge) this toX with the supplied Iterable into a Colleciton containing Tuples Each Tuple contains one element from this toX and one from the other
`<U,R> CollectionX<R>`	`zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
`<S,U> CollectionX<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> CollectionX<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> CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipS(java.util.stream.Stream<? extends U> other)` Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
`<U,R> CollectionX<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
`CollectionX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream

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

Methods inherited from interface com.aol.cyclops2.types.foldable.CyclopsCollectable
allMatch, anyMatch, collect, collectors, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, maxBy, min, minBy, mode, noneMatch, sum, sumDouble, sumInt, sumLong, to, toList, toMap, toMap, toSet, toString, toString

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds
endsWith, endsWithIterable, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, startsWith, startsWithIterable, xMatch

Methods inherited from interface com.aol.cyclops2.types.traversable.Traversable
append, append, combine, deleteBetween, insertAt, insertAtS, mapToDouble, mapToInt, mapToLong, prepend, prepend, prependS, recover, recover, subscribe, traversable, unitIterator, zip, zip3, zip4, zipP, zipP, zipWith, zipWithP, zipWithS

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface com.aol.cyclops2.types.Filters
ofType

Methods inherited from interface com.aol.cyclops2.types.functor.Transformable
retry, retry

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

Methods inherited from interface com.aol.cyclops2.types.traversable.Sequential
fixedDelay, onePer, xPer

Methods inherited from interface java.util.Collection
add, addAll, clear, contains, containsAll, equals, hashCode, parallelStream, remove, removeAll, removeIf, retainAll, size, spliterator, toArray, toArray

Methods inherited from interface com.aol.cyclops2.types.Unwrapable
unwrap, unwrapIfInstance, unwrapNested

- Method Detail
 - isLazy
```
boolean isLazy()
```
 - isEager
```
boolean isEager()
```
 - evaluation
```
Evaluation evaluation()
```
 - lazy
```
CollectionX<T> lazy()
```
 - eager
```
CollectionX<T> eager()
```
 - toX
```
default <R> R toX(java.util.function.Function<? super CollectionX<T>,? extends R> fn)
```
 - iterator
```
java.util.Iterator<T> iterator()
```
 Specified by:
 
 iterator in interface java.util.Collection<T>
 
 Specified by:
 
 iterator in interface java.lang.Iterable<T>
 - isEmpty
```
boolean isEmpty()
```
 Specified by:
 
 isEmpty in interface java.util.Collection<T>
 - flatMapS
```
default <R> CollectionX<R> flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)
```
 - flatMapP
```
<R> CollectionX<R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
 - flatMapP
```
<R> CollectionX<R> flatMapP(int maxConcurecy,
 java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
 - fromCollection
```
static <T> CollectionX<T> fromCollection(java.util.Collection<T> col)
```
 Create a CollectionX from the supplied Collection
 
 Parameters:
 
 col -
 
 Returns:
 - unit
```
<R> CollectionX<R> unit(R r)
```
 Specified by:
 
 unit in interface Unit<T>
 - grouped
```
<C extends java.util.Collection<? super T>> CollectionX<C> grouped(int size,
 java.util.function.Supplier<C> supplier)
```
 Description copied from interface: Traversable
 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>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 SequenceM batched into toX types by size
 - groupedUntil
```
CollectionX<ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Create a Traversable batched by List, where each batch is populated until the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedUntil(i->i%3==0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, applyHKT open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedStatefullyUntil
```
CollectionX<ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
```
 Description copied from interface: Traversable
 Create Travesable of 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
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedStatefullyUntil((s,i)->s.contains(4) ? true : false)
 .toList().size(),equalTo(5));
 
 
```
 Specified by:
 
 groupedStatefullyUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 Traversable windowed while predicate holds
 - groupedWhile
```
CollectionX<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Create a Traversable batched by List, where each batch is populated while the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedWhile(i->i%3!=0)
 .toList().size(),equalTo(2));
 
 
 
```
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, applyHKT open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedWhile
```
<C extends java.util.Collection<? super T>> CollectionX<C> groupedWhile(java.util.function.Predicate<? super T> predicate,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: Traversable
 Create a SequenceM 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>
 
 Parameters:
 
 predicate - Batch while predicate holds, applyHKT open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - groupedUntil
```
<C extends java.util.Collection<? super T>> CollectionX<C> groupedUntil(java.util.function.Predicate<? super T> predicate,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: Traversable
 Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .groupedUntil(i->i%3!=0)
 .toList()
 
 //2
 
 
```
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, applyHKT open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - intersperse
```
CollectionX<T> intersperse(T value)
```
 Description copied from interface: Traversable
 
 Returns a reactiveStream with a given value interspersed between any two values of this reactiveStream. // (1, 0, 2, 0, 3, 0, 4) ReactiveSeq.of(1, 2, 3, 4).intersperse(0)
 
 Specified by:
 
 intersperse in interface Traversable<T>
 - shuffle
```
CollectionX<T> shuffle()
```
 Specified by:
 
 shuffle in interface Traversable<T>
 - shuffle
```
CollectionX<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface Traversable<T>
 - zip3
```
<S,U> CollectionX<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: Traversable
 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>
 - zip4
```
<T2,T3,T4> CollectionX<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: Traversable
 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>
 - limitWhile
```
CollectionX<T> limitWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 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>
 
 Parameters:
 
 p - Limit while predicate is true
 
 Returns:
 
 Stream with limited elements
 - limitUntil
```
CollectionX<T> limitUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 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>
 
 Parameters:
 
 p - Limit until predicate is true
 
 Returns:
 
 Stream with limited elements
 - limitLast
```
CollectionX<T> limitLast(int num)
```
 Description copied from interface: Traversable
 Limit results to the last x elements in a SequenceM
```
 
 	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>
 
 Parameters:
 
 num - of elements to return (last elements)
 
 Returns:
 
 SequenceM limited to last num elements
 - skipWhile
```
CollectionX<T> skipWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 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>
 
 Parameters:
 
 p - Predicate to skip while true
 
 Returns:
 
 Stream with elements skipped while predicate holds
 - skipUntil
```
CollectionX<T> skipUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Drop elements from the Stream until the predicate returns true, after which all elements are included
```
 assertThat(ReactiveSeq.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
 
```
 Specified by:
 
 skipUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to skip until true
 
 Returns:
 
 Stream with elements skipped until predicate holds
 - skipLast
```
CollectionX<T> skipLast(int num)
```
 Description copied from interface: Traversable
 
 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>
 
 Returns:
 - cycle
```
CollectionX<T> cycle(long times)
```
 Description copied from interface: Traversable
 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>
 
 Parameters:
 
 times - Times values should be repeated within a Stream
 
 Returns:
 
 Stream with values repeated
 - cycle
```
CollectionX<T> cycle(Monoid<T> m,
 long times)
```
 Description copied from interface: Traversable
 Convert to a Stream with the result of a reduction operation repeated specified times
```
 
 List<Integer> list = ReactiveSeq.of(1,2,2))
 .cycle(Reducers.toCountInt(),3)
 .collect(CyclopsCollectors.toList());
 //List[3,3,3];
 
 
```
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 m - Monoid to be used in reduction
 
 times - Number of times value should be repeated
 
 Returns:
 
 Stream with reduced values repeated
 - cycleWhile
```
CollectionX<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Repeat in a Stream while specified predicate holds
```
 
 MutableInt count = MutableInt.of(0);
 ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6).collect(CyclopsCollectors.toList());
 
 // List(1,2,2,1,2,2)
 
 
```
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - cycleUntil
```
CollectionX<T> cycleUntil(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Repeat in a Stream until specified predicate holds
```
 
 	MutableInt count =MutableInt.of(0);
 		ReactiveSeq.of(1,2,2)
 		 		.cycleUntil(next -> count.get()>6)
 		 		.peek(i-> count.mutate(i->i+1))
 		 		.collect(CyclopsCollectors.toList());
 
 		//List[1,2,2,1,2,2,1]	
 
 
```
 Specified by:
 
 cycleUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - onEmpty
```
CollectionX<T> onEmpty(T value)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is zero, create a new instance containing the provided value
 
 Specified by:
 
 onEmpty in interface OnEmpty<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 
 Returns:
 
 New instance containing value if container is zero, otherwise returns this container
 - onEmptyGet
```
CollectionX<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>
 
 Parameters:
 
 supplier - to determine new value for container
 
 Returns:
 
 New Container with value if this is zero, otherwise this container
 - onEmptyThrow
```
<X extends java.lang.Throwable> CollectionX<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>
 
 Parameters:
 
 supplier - to create exception from
 
 Returns:
 
 Throw exception if zero, otherwise this container
 - stream
```
default ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface java.util.Collection<T>
 
 Specified by:
 
 stream in interface ExtendedTraversable<T>
 
 Specified by:
 
 stream in interface FoldableTraversable<T>
 
 Specified by:
 
 stream in interface Folds<T>
 
 Specified by:
 
 stream in interface Sequential<T>
 
 Specified by:
 
 stream in interface TransformerTraversable<T>
 
 Specified by:
 
 stream in interface Traversable<T>
 
 Returns:
 
 This Traversable converted to a Stream
 - isMaterialized
```
boolean isMaterialized()
```
 - materialize
```
default CollectionX<T> materialize()
```
 - materializeReversed
```
default CollectionX<T> materializeReversed()
```
 - getAtIndex
```
default Maybe<T> getAtIndex(int index)
```
 Get the element at the specified index (if it exists)
 
 Parameters:
 
 index - to look up element
 
 Returns:
 
 Optional.zero if the index does not exist, otherwise the element at the index supplied is returned
 - headAndTail
```
default 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>
 
 Returns:
 - head
```
default T head()
```
 Returns:
 
 The head of this toX
 - from
```
<T1> CollectionX<T1> from(java.util.Collection<T1> c)
```
 Conctruct an Extended Collection from a standard Collection
 
 Parameters:
 
 c - Collection to extend
 
 Returns:
 
 Extended Collection
 - reverse
```
CollectionX<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>
 - singleUnsafe
```
default T singleUnsafe()
```
 Description copied from interface: Folds
```
 
 
 //1
 ReactiveSeq.of(1).singleUnsafe();
 
 //UnsupportedOperationException
 ReactiveSeq.of().singleUnsafe();
 
 //UnsupportedOperationException
 ReactiveSeq.of(1,2,3).singleUnsafe();
 
 
```
 Specified by:
 
 singleUnsafe in interface Folds<T>
 
 Returns:
 
 a singleUnsafe value or an UnsupportedOperationException if 0/1 values in this Stream
 - single
```
default Maybe<T> single(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 single in interface Folds<T>
 - single
```
default Maybe<T> single()
```
 Description copied from interface: Folds
```
 
 
 //Optional[1]
 ReactiveSeq.of(1).singleUnsafe();
 
 //Optional.zero
 ReactiveSeq.of().singleOpional();
 
 //Optional.zero
 ReactiveSeq.of(1,2,3).singleUnsafe();
 
 
```
 Specified by:
 
 single in interface Folds<T>
 
 Returns:
 
 An Optional with singleUnsafe value if this Stream has exactly one element, otherwise Optional Empty
 - takeOne
```
default Maybe<T> takeOne()
```
 Specified by:
 
 takeOne in interface Folds<T>
 - findFirst
```
default java.util.Optional<T> findFirst()
```
 Specified by:
 
 findFirst in interface Folds<T>
 
 Returns:
 First matching element in sequential order
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findFirst().get(); //3
 (deterministic)
 - findAny
```
default java.util.Optional<T> findAny()
```
 Specified by:
 
 findAny in interface Folds<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)
 - groupBy
```
default <K> MapX<K,ListX<T>> groupBy(java.util.function.Function<? super T,? extends K> classifier)
```
 Description copied from interface: Folds
 Use classifier function to group elements in this Sequence into a Map
```
 
 
 Map<Integer, List<Integer>> map1 = of(1, 2, 3, 4).groupBy(i -&gt; i % 2);
 assertEquals(asList(2, 4), map1.get(0));
 assertEquals(asList(1, 3), map1.get(1));
 assertEquals(2, map1.size());
 
 
 
 
```
 Specified by:
 
 groupBy in interface Folds<T>
 - filter
```
CollectionX<T> filter(java.util.function.Predicate<? super T> pred)
```
 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 FilterableTransformable<T>
 
 Specified by:
 
 filter in interface Filters<T>
 
 Parameters:
 
 pred - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - map
```
<R> CollectionX<R> map(java.util.function.Function<? super T,? extends R> mapper)
```
 Description copied from interface: Transformable
 Transform this functor using the supplied transformation function
```
 


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

 //[2,4,6]

 
 
```
 Specified by:
 
 map in interface FilterableTransformable<T>
 
 Specified by:
 
 map in interface Transformable<T>
 
 Parameters:
 
 mapper - Transformation function
 
 Returns:
 
 Transformed Transformable
 - flatMap
```
<R> CollectionX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
```
 Perform a flatMap operation on this toX. Results from the returned Iterables (from the provided transformation function) are flattened into the resulting toX.
 
 Parameters:
 
 mapper - Transformation function to be applied (and flattened)
 
 Returns:
 
 A toX containing the flattened results of the transformation function
 - limit
```
CollectionX<T> limit(long num)
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
 
```
 Specified by:
 
 limit in interface Traversable<T>
 
 Parameters:
 
 num - Limit element size to num
 
 Returns:
 
 Monad converted to Stream with elements up to num
 - take
```
default CollectionX<T> take(long num)
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));
 
```
 Specified by:
 
 take in interface Traversable<T>
 
 Parameters:
 
 num - Limit element size to num
 
 Returns:
 
 Monad converted to Stream with elements up to num
 - drop
```
default CollectionX<T> drop(long num)
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
 Specified by:
 
 drop in interface Traversable<T>
 
 Parameters:
 
 num - Number of elemenets to drop
 
 Returns:
 
 Traversable with specified number of elements skipped
 - skip
```
CollectionX<T> skip(long num)
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
 Specified by:
 
 skip in interface Traversable<T>
 
 Parameters:
 
 num - Number of elemenets to skip
 
 Returns:
 
 Stream with specified number of elements skipped
 - takeWhile
```
CollectionX<T> takeWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
```
 
 ListX.of(1,2,3).takeWhile(i<3);
 //[1,2]
 
 
```
 Specified by:
 
 takeWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be taken
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropWhile
```
CollectionX<T> dropWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
```
 
 ListX.of(1,2,3).dropWhile(i<3);
 //[3]
 
 
```
 Specified by:
 
 dropWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - takeUntil
```
CollectionX<T> takeUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes elements from this Traversable until the predicate holds
```
 
 ListX.of(1,2,3).takeUntil(i<2);
 //[1,2]
 
 
```
 Specified by:
 
 takeUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be taken until
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropUntil
```
CollectionX<T> dropUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops elements from this Traversable until the predicate holds
```
 
 ListX.of(1,2,3).dropUntil(i>2);
 //[3]
 
 
```
 Specified by:
 
 dropUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropRight
```
CollectionX<T> dropRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops the specified number elements from the take of this Traversable
```
 
 ListX.of(1,2,3).dropRight(2);
 //[1]
 
 
```
 Specified by:
 
 dropRight in interface Traversable<T>
 
 Parameters:
 
 num - Drop this number of elements from the take of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - takeRight
```
CollectionX<T> takeRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes the specified number elements from the take of this Traversable
```
 
 ListX.of(1,2,3).takeRight(2);
 //[2,3]
 
 
```
 Specified by:
 
 takeRight in interface Traversable<T>
 
 Parameters:
 
 num - Take this number of elements from the take of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - peek
```
default CollectionX<T> peek(java.util.function.Consumer<? super T> c)
```
 Description copied from interface: Transformable
 Peek at the current value of this Transformable, without transforming it
```
 


 of(1,2,3).map(System.out::println)

 1
 2
 3

 
 
```
 Specified by:
 
 peek in interface Transformable<T>
 
 Parameters:
 
 c - Consumer that recieves each element from this Transformable
 
 Returns:
 
 Transformable that will peek at each value
 - grouped
```
CollectionX<ListX<T>> grouped(int groupSize)
```
 Description copied from interface: Traversable
 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>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - grouped
```
<K,A,D> CollectionX<org.jooq.lambda.tuple.Tuple2<K,D>> grouped(java.util.function.Function<? super T,? extends K> classifier,
 java.util.stream.Collector<? super T,A,D> downstream)
```
 Description copied from interface: Traversable
 
 Group this Traversable by the provided classifying function and collected by the provided Collector
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 classifier - Grouping function
 
 downstream - Collector to create the grouping toX
 
 Returns:
 
 Traversable of grouped data
 - grouped
```
<K> CollectionX<org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
```
 Description copied from interface: Traversable
 
 Group this Traversable by the provided classifying function and collected by the provided Collector
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 classifier - Grouping function
 
 Returns:
 
 Traversable of grouped data
 - combine
```
CollectionX<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
 java.util.function.BinaryOperator<T> op)
```
 Description copied from interface: Traversable
 Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation. The emitted of a combination may in turn be combined with it's neighbour
```
 
 ReactiveSeq.of(1,1,2,3)
 .combine((a, b)->a.equals(b),SemigroupK.intSum)
 .listX()
 
 //ListX(3,4) 
 
```
 Specified by:
 
 combine in interface Traversable<T>
 
 Parameters:
 
 predicate - Test to see if two neighbours should be joined. The first parameter to the bi-predicate is the currently accumulated result and the second is the next element
 
 op - BinaryOperator to combine neighbours
 
 Returns:
 
 Combined / Partially Reduced Traversable
 - zip
```
 CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
```
 Zip (merge) this toX with the supplied Iterable into a Colleciton containing Tuples Each Tuple contains one element from this toX and one from the other
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Collection to merge with this one
 
 Returns:
 
 Merged toX
 - zip
```
<U,R> CollectionX<R> zip(java.lang.Iterable<? 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 Iterable using the supplied combining function
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - to zip with
 
 zipper - Zip function
 
 Returns:
 
 Combined zippable
 - zipS
```
<U,R> CollectionX<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>
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zipS
```
 CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)
```
 Description copied from interface: Traversable
 
 Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
 
 Specified by:
 
 zipS in interface Traversable<T>
 
 Specified by:
 
 zipS in interface Zippable<T>
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - zipWithIndex
```
CollectionX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()
```
 Description copied from interface: Traversable
 Add an index to the current Stream
```
 
 assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").zipWithIndex().toList());
 
 
```
 Specified by:
 
 zipWithIndex in interface Traversable<T>
 - sliding
```
CollectionX<VectorX<T>> sliding(int windowSize)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(2).collect(CyclopsCollectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2));
 assertThat(list.get(1), hasItems(2, 3));
 
 
 
 
```
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - Size of sliding window
 
 Returns:
 
 SequenceM with sliding view
 - sliding
```
CollectionX<VectorX<T>> sliding(int windowSize,
 int increment)
```
 Description copied from interface: Traversable
 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>
 
 Parameters:
 
 windowSize - number of elements in each batch
 
 increment - for each window
 
 Returns:
 
 SequenceM with sliding view
 - scanLeft
```
CollectionX<T> scanLeft(Monoid<T> monoid)
```
 Description copied from interface: Traversable
 Scan left using supplied Monoid
```
 
 
 	assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
 													.scanLeft(Reducers.toString("")).toList());
 
 
 
```
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Returns:
 - scanLeft
```
 CollectionX scanLeft(U seed,
 java.util.function.BiFunction<? super U,? super T,? extends U> function)
```
 Description copied from interface: Traversable
 Scan left
```
 
 assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
 		is(4));
 
 
```
 Specified by:
 
 scanLeft in interface Traversable<T>
 - scanRight
```
CollectionX<T> scanRight(Monoid<T> monoid)
```
 Description copied from interface: Traversable
 Scan right
```
 
 assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
 is(asList("", "c", "bc", "abc").size()));
 
 
```
 Specified by:
 
 scanRight in interface Traversable<T>
 - scanRight
```
 CollectionX scanRight(U identity,
 java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
```
 Description copied from interface: Traversable
 Scan right
```
 
 assertThat(of("a", "ab", "abc").map(str->str.length()).scanRight(0, (t, u) -> u + t).toList().size(),
 is(asList(0, 3, 5, 6).size()));
 
 
 
```
 Specified by:
 
 scanRight in interface Traversable<T>
 - distinct
```
CollectionX<T> distinct()
```
 Specified by:
 
 distinct in interface Traversable<T>
 - sorted
```
CollectionX<T> sorted()
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); 
 
```
 Specified by:
 
 sorted in interface Traversable<T>
 - removeAllS
```
CollectionX<T> removeAllS(java.util.stream.Stream<? extends T> stream)
```
 Description copied from interface: IterableFilterable
 
 Remove all elements in the supplied Stream from this filterable
 
 Specified by:
 
 removeAllS in interface IterableFilterable<T>
 
 Parameters:
 
 stream - of elements to remove
 
 Returns:
 
 Filters with all supplied elements removed
 - removeAllI
```
CollectionX<T> removeAllI(java.lang.Iterable<? extends T> it)
```
 Description copied from interface: IterableFilterable
 
 Remove all elements in the supplied Iterable from this filterable
 
 Specified by:
 
 removeAllI in interface IterableFilterable<T>
 
 Parameters:
 
 it - an Iterable of elements to remove
 
 Returns:
 
 Filters with all supplied elements removed
 - removeAll
```
CollectionX<T> removeAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Remove all supplied elements from this filterable
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Parameters:
 
 values - to remove
 
 Returns:
 
 Filters with all supplied values removed
 - retainAllI
```
CollectionX<T> retainAllI(java.lang.Iterable<? extends T> it)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filters
 
 Specified by:
 
 retainAllI in interface IterableFilterable<T>
 
 Parameters:
 
 it - Iterable of elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retainAllS
```
CollectionX<T> retainAllS(java.util.stream.Stream<? extends T> seq)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filters
 
 Specified by:
 
 retainAllS in interface IterableFilterable<T>
 
 Parameters:
 
 seq - of elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retainAll
```
CollectionX<T> retainAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filters
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Parameters:
 
 values - elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - filterNot
```
CollectionX<T> filterNot(java.util.function.Predicate<? super T> fn)
```
 Description copied from interface: Filters
 Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
 
 
 of(1,2,3).filter(i->i>2);
 
 //[1,2]
 
 
 
```
 Specified by:
 
 filterNot in interface Filters<T>
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - notNull
```
CollectionX<T> notNull()
```
 Description copied from interface: Filters
 Filter elements retaining only values which are not null
```
 
 
 of(1,2,null,4).nonNull();
 
 //[1,2,4]
 
 
 
```
 Specified by:
 
 notNull in interface Filters<T>
 
 Returns:
 
 Filters with nulls removed
 - trampoline
```
<R> CollectionX<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
```
 Description copied from interface: Transformable
 Performs a map operation that can call a recursive method without running out of stack space
```
 
 ReactiveSeq.of(10,20,30,40)
 			 .trampoline(i-> fibonacci(i))
 			 .forEach(System.out::println);

 	Trampoline<Long> fibonacci(int i){
 		return fibonacci(i,1,0);
 	}
 	Trampoline<Long> fibonacci(int n, long a, long b) {
 	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
 	}

 55
 	6765
 	832040
 	102334155


 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
 			 .trampoline(i-> fibonacci(i))
 			 .forEach(System.out::println);


 completes successfully
 
 
```
 Specified by:
 
 trampoline in interface Transformable<T>
 
 Parameters:
 
 mapper - TCO Transformation function
 
 Returns:
 
 Transformable transformed by the supplied transformation function
 - forEach4
```
default <R1,R2,R3,R> CollectionX<R> forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
 Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3,
 Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
```
 Perform a three level nested internal iteration over this Stream and the supplied streams
```
 
 
 //collectionX [1,2]
 
 collectionX.forEach4(a->ListX.range(10,13),
 (a,b)->ListX.of(""+(a+b),"hello world"),
 (a,b,c)->ListX.of(a,b,c)),
 (a,b,c,d)->c+":"a+":"+b);
 
 
 
```
 Parameters:
 
 iterable1 - Nested Stream to iterate over
 
 iterable2 - Nested Stream to iterate over
 
 iterable3 - Nested Stream to iterate over
 
 yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
 
 Returns:
 
 CollectionX with elements generated via nested iteration
 - forEach4
```
default <R1,R2,R3,R> CollectionX<R> forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
 Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3,
 Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
 Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
```
 Perform a three level nested internal iteration over this Stream and the supplied streams
```
 
 //collectionX [1,2,3]
 
 collectionX.forEach4(a->ListX.range(10,13),
 (a,b)->ListX.of(""+(a+b),"hello world"),
 (a,b,c)->ListX.of(a,b,c),
 (a,b,c,d)-> c!=3,
 (a,b,c)->c+":"a+":"+b);
 
 
 
 
 
```
 Parameters:
 
 iterable1 - Nested Stream to iterate over
 
 iterable2 - Nested Stream to iterate over
 
 iterable3 - Nested Stream to iterate over
 
 filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function
 
 yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
 
 Returns:
 
 CollectionX with elements generated via nested iteration
 - forEach3
```
default <R1,R2,R> CollectionX<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
 Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
```
 Perform a three level nested internal iteration over this Stream and the supplied streams
```
 
 
 //collectionX [1,2]
 
 collectionX.forEach3(a->IntStream.range(10,13),
 (a,b)->Stream.of(""+(a+b),"hello world"),
 (a,b,c)->c+":"a+":"+b);
 
 
 //CollectionX[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
 
 
```
 Parameters:
 
 iterable1 - Nested Stream to iterate over
 
 iterable2 - Nested Stream to iterate over
 
 yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
 
 Returns:
 
 ReactiveSeq with elements generated via nested iteration
 - forEach3
```
default <R1,R2,R> CollectionX<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
 Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
 Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
```
 Perform a three level nested internal iteration over this Stream and the supplied streams
```
 
 //collectionX [1,2,3]
 
 collectionX.forEach3(a->ListX.range(10,13),
 (a,b)->Stream.of(""+(a+b),"hello world"),
 (a,b,c)-> c!=3,
 (a,b,c)->c+":"a+":"+b);
 
 
 //CollectionX[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
 
 
```
 Parameters:
 
 iterable1 - Nested Stream to iterate over
 
 iterable2 - Nested Stream to iterate over
 
 filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function
 
 yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
 
 Returns:
 
 ReactiveSeq with elements generated via nested iteration
 - forEach2
```
default <R1,R> CollectionX<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
```
 Perform a two level nested internal iteration over this Stream and the supplied reactiveStream
```
 
 //collectionX [1,2,3]
 
 collectionX.of(1,2,3).forEach2(a->ListX.range(10,13),
 (a,b)->a+b);
 
 
 //ReactiveSeq[11,14,12,15,13,16]
 
 
```
 Parameters:
 
 iterable1 - Nested Iterable to iterate over
 
 yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
 
 Returns:
 
 ReactiveSeq with elements generated via nested iteration
 - forEach2
```
default <R1,R> CollectionX<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
 java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
```
 Perform a two level nested internal iteration over this Stream and the supplied reactiveStream
```
 
 
 //collectionX [1,2,3]
 
 collectionX.of(1,2,3).forEach2(a->ListX.range(10,13),
 (a,b)-> a<3 && b>10,
 (a,b)->a+b);
 
 
 //CollectionX[14,15]
 
 
```
 Parameters:
 
 iterable1 - Nested Stream to iterate over
 
 filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function
 
 yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
 
 Returns:
 
 ReactiveSeq with elements generated via nested iteration
 - slice
```
CollectionX<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface Traversable<T>
 - sorted
```
> CollectionX<T> sorted(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 sorted in interface Traversable<T>
 - sorted
```
CollectionX<T> sorted(java.util.Comparator<? super T> c)
```
 Description copied from interface: Traversable
```
 
 	assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
 
 
```
 Specified by:
 
 sorted in interface Traversable<T>
 
 Parameters:
 
 c - Compartor to sort with
 
 Returns:
 
 Sorted Stream
 - permutations
```
CollectionX<ReactiveSeq<T>> permutations()
```
 Description copied from interface: ExtendedTraversable
 
 Generate the permutations based on values in the ExtendedTraversable.
 
 Specified by:
 
 permutations in interface ExtendedTraversable<T>
 
 Returns:
 
 Permutations from this ExtendedTraversable
 - combinations
```
CollectionX<ReactiveSeq<T>> combinations(int size)
```
 Description copied from interface: ExtendedTraversable
 Generate the combinations based on values in the ExtendedTraversable.
```
 
 ExtendedTraversable<Integer> reactiveStream = ReactiveSeq.of(1,2,3);
 reactiveStream.combinations(2)
 
 //ReactiveSeq[ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]]
 
 
```
 Specified by:
 
 combinations in interface ExtendedTraversable<T>
 
 Parameters:
 
 size - of combinations
 
 Returns:
 
 All combinations of the elements in this ExtendedTraversable of the specified size
 - combinations
```
CollectionX<ReactiveSeq<T>> combinations()
```
 Description copied from interface: ExtendedTraversable
 Generate the combinations based on values in the ExtendedTraversable.
```
 
 ReactiveSeq.of(1,2,3).combinations()
 
 //ReactiveSeq[ReactiveSeq[],ReactiveSeq[1],ReactiveSeq[2],ReactiveSeq[3].ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]
 			,ReactiveSeq[1,2,3]]
 
 
```
 Specified by:
 
 combinations in interface ExtendedTraversable<T>
 
 Returns:
 
 All combinations of the elements in this ExtendedTraversable
 - cast
```
default  CollectionX cast(java.lang.Class<? extends U> type)
```
 Description copied from interface: Transformable
 
 Cast all elements in a reactiveStream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)
 
 Specified by:
 
 cast in interface Transformable<T>

Interface CollectionX<T>

Method Summary

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 java.lang.Iterable

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

Methods inherited from interface com.aol.cyclops2.types.functor.Transformable

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

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

Methods inherited from interface java.util.Collection

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

Method Detail

isLazy

isEager

evaluation

lazy

eager

toX

iterator

isEmpty

flatMapS

flatMapP

flatMapP

fromCollection

unit

grouped

groupedUntil

groupedStatefullyUntil

groupedWhile

groupedWhile

groupedUntil

intersperse

shuffle

shuffle

zip3

zip4

limitWhile

limitUntil

limitLast

skipWhile

skipUntil

skipLast

cycle

cycle

cycleWhile

cycleUntil

onEmpty

onEmptyGet

onEmptyThrow

stream

isMaterialized

materialize

materializeReversed

getAtIndex

headAndTail

head

from

reverse

singleUnsafe

single

single

takeOne

findFirst

findAny

groupBy

filter

map

flatMap

limit

take

drop

skip

takeWhile

dropWhile

takeUntil

dropUntil

dropRight

takeRight