SortedSetX (simple-react 1.0.0-RC2.1 API)

All Superinterfaces:

org.jooq.lambda.Collectable<T>, java.util.Collection<T>, CollectionX<T>, ConvertableSequence<T>, CyclopsCollectable<T>, ExtendedTraversable<T>, Filterable<T>, FluentCollectionX<T>, Foldable<T>, Functor<T>, java.lang.Iterable<T>, IterableCollectable<T>, IterableFilterable<T>, IterableFunctor<T>, MutableCollectionX<T>, org.reactivestreams.Publisher<T>, Sequential<T>, java.util.Set<T>, java.util.SortedSet<T>, Traversable<T>, Unit<T>, ZippingApplicativable<T>

All Known Implementing Classes:

SortedSetXImpl
```
public interface SortedSetX<T>
extends java.util.SortedSet<T>, MutableCollectionX<T>
```

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class SortedSetX.Comparables

Nested Classes
Modifier and Type	Interface and Description
`static class`	`SortedSetX.Comparables`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <U> SortedSetX<U>`	`cast(java.lang.Class<U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default SortedSetX<ReactiveSeq<T>>`	`combinations()` `ReactiveSeq.of(1,2,3).combinations() //SequenceM[SequenceM[],SequenceM[1],SequenceM[2],SequenceM[3].SequenceM[1,2],SequenceM[1,3],SequenceM[2,3] ,SequenceM[1,2,3]]`
`default SortedSetX<ReactiveSeq<T>>`	`combinations(int size)` `ReactiveSeq.of(1,2,3).combinations(2) //SequenceM[SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]]`
`default SortedSetX<T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)` Combine two adjacent elements in a SortedSetX using the supplied BinaryOperator This is a stateful grouping & reduction operation.
`default ListX<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`default ListX<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`default ListX<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`default ListX<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`static <T> java.util.stream.Collector<T,?,java.util.SortedSet<T>>`	`defaultCollector()`
`default SortedSetX<T>`	`distinct()`
`default SortedSetX<T>`	`dropRight(int num)`
`default SortedSetX<T>`	`dropUntil(java.util.function.Predicate<? super T> p)`
`default SortedSetX<T>`	`dropWhile(java.util.function.Predicate<? super T> p)`
`static <T> SortedSetX<T>`	`empty()`
`default SortedSetX<T>`	`filter(java.util.function.Predicate<? super T> pred)`
`default SortedSetX<T>`	`filterNot(java.util.function.Predicate<? super T> fn)`
`default <R> SortedSetX<R>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)`
`default <T1> SortedSetX<T1>`	`from(java.util.Collection<T1> c)`
`static <T> SortedSetX<T>`	`fromIterable(java.util.stream.Collector<T,?,java.util.SortedSet<T>> collector, java.lang.Iterable<T> it)`
`static <T> SortedSetX<T>`	`fromIterable(java.lang.Iterable<T> it)`
`default <X> SortedSetX<X>`	`fromStream(java.util.stream.Stream<X> stream)`
`<T> java.util.stream.Collector<T,?,java.util.SortedSet<T>>`	`getCollector()`
`default <K> SortedSetX<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier)`
`default <K,A,D> SortedSetX<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)`
`default SortedSetX<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`default <C extends java.util.Collection<? super T>> SortedSetX<C>`	`grouped(int size, java.util.function.Supplier<C> supplier)` Batch elements in a Stream by size into a collection created by the supplied factory
`default SortedSetX<ListX<T>>`	`groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)` Create SequenceM of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied bipredicate holds.
`default SortedSetX<ListX<T>>`	`groupedUntil(java.util.function.Predicate<? super T> predicate)` Create a SequenceM batched by List, where each batch is populated until the predicate holds
`default <C extends java.util.Collection<? super T>> SortedSetX<C>`	`groupedUntil(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 until the predicate holds
`default SortedSetX<ListX<T>>`	`groupedWhile(java.util.function.Predicate<? super T> predicate)` Create a SequenceM batched by List, where each batch is populated while the predicate holds
`default <C extends java.util.Collection<? super T>> SortedSetX<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
`static <T> java.util.stream.Collector<T,?,java.util.SortedSet<T>>`	`immutableCollector()`
`default SortedSetX<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`default SortedSetX<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`default SortedSetX<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`default SortedSetX<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.
`default SortedSetX<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
`default <R> SortedSetX<R>`	`map(java.util.function.Function<? super T,? extends R> mapper)`
`default SortedSetX<T>`	`minus(java.lang.Object e)`
`default SortedSetX<T>`	`minusAll(java.util.Collection<?> list)`
`default SortedSetX<T>`	`notNull()`
`static <T> SortedSetX<T>`	`of(T... values)`
`default <U> SortedSetX<U>`	`ofType(java.lang.Class<U> type)` Keep only those elements in a stream that are of a given type.
`default SortedSetX<T>`	`onEmpty(T value)`
`default SortedSetX<T>`	`onEmptyGet(java.util.function.Supplier<T> supplier)`
`default <X extends java.lang.Throwable> SortedSetX<T>`	`onEmptyThrow(java.util.function.Supplier<X> supplier)`
`default <R> SortedSetX<R>`	`patternMatch(java.util.function.Function<Matchable.CheckValues<T,R>,Matchable.CheckValues<T,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`default SortedSetX<ReactiveSeq<T>>`	`permutations()` Generate the permutations based on values in the SequenceM Makes use of Streamable to store intermediate stages in a collection
`default SortedSetX<T>`	`plus(T e)`
`default SortedSetX<T>`	`plusAll(java.util.Collection<? extends T> list)`
`default SortedSetX<T>`	`removeAll(java.lang.Iterable<T> it)`
`default SortedSetX<T>`	`removeAll(org.jooq.lambda.Seq<T> stream)`
`default SortedSetX<T>`	`removeAll(java.util.stream.Stream<T> stream)`
`default SortedSetX<T>`	`removeAll(T... values)`
`default SortedSetX<T>`	`retainAll(java.lang.Iterable<T> it)`
`default SortedSetX<T>`	`retainAll(org.jooq.lambda.Seq<T> stream)`
`default SortedSetX<T>`	`retainAll(java.util.stream.Stream<T> stream)`
`default SortedSetX<T>`	`retainAll(T... values)`
`default SortedSetX<T>`	`reverse()`
`default SortedSetX<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`default <U> SortedSetX<U>`	`scanLeft(U seed, java.util.function.BiFunction<U,? super T,U> function)` Scan left
`default SortedSetX<T>`	`scanRight(Monoid<T> monoid)` Scan right
`default <U> SortedSetX<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,U,U> combiner)` Scan right
`default SortedSetX<T>`	`shuffle()`
`default SortedSetX<T>`	`shuffle(java.util.Random random)`
`static <T> SortedSetX<T>`	`singleton(T value)`
`default SortedSetX<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`default SortedSetX<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`default SortedSetX<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
`default SortedSetX<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 *
`default SortedSetX<T>`	`slice(long from, long to)`
`default SortedSetX<ListX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`default SortedSetX<ListX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`default SortedSetX<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`default SortedSetX<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)));`
`default <U extends java.lang.Comparable<? super U>> SortedSetX<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`default ReactiveSeq<T>`	`stream()`
`default SortedSetX<T>`	`takeRight(int num)`
`default SortedSetX<T>`	`takeUntil(java.util.function.Predicate<? super T> p)`
`default SortedSetX<T>`	`takeWhile(java.util.function.Predicate<? super T> p)`
`default SortedSetX<T>`	`toSortedSetX()`
`default <R> SortedSetX<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
`default <R> SortedSetX<R>`	`unit(java.util.Collection<R> col)`
`default <R> SortedSetX<R>`	`unit(R value)`
`default <R> SortedSetX<R>`	`unitIterator(java.util.Iterator<R> it)`
`default <U> SortedSetX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<U> other)`
`default <U,R> SortedSetX<R>`	`zip(java.lang.Iterable<U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <U> SortedSetX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<U> other)` Zip 2 streams into one
`default <S,U> SortedSetX<org.jooq.lambda.tuple.Tuple3<T,S,U>>`	`zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends U> third)` zip 3 Streams into one
`default <T2,T3,T4> SortedSetX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.util.stream.Stream<T2> second, java.util.stream.Stream<T3> third, java.util.stream.Stream<T4> fourth)` zip 4 Streams into 1
`default <U> SortedSetX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipStream(java.util.stream.Stream<U> other)` Zip 2 streams into one
`default SortedSetX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream

Methods inherited from interface java.util.SortedSet
comparator, first, headSet, last, spliterator, subSet, tailSet

Methods inherited from interface java.util.Set
add, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toArray

Methods inherited from interface com.aol.cyclops.data.collections.extensions.FluentCollectionX
plusInOrder

Methods inherited from interface com.aol.cyclops.data.collections.extensions.CollectionX
collectable, findAny, findFirst, forEach2, forEach2, forEach3, forEach3, fromCollection, getAtIndex, groupBy, head, headAndTail, peek, single, single, singleOptional

Methods inherited from interface com.aol.cyclops.types.IterableCollectable
xMatch

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

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

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

Methods inherited from interface java.util.Collection
parallelStream, removeIf

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable
allMatch, anyMatch, avg, avg, avgDouble, avgInt, avgLong, collect, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, max, max, max, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, min, minBy, minBy, mode, noneMatch, percentile, percentile, percentileBy, percentileBy, sum, sum, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toSet, toSet, toString, toString

Methods inherited from interface org.jooq.lambda.Collectable
collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect

- Method Detail
 - defaultCollector
```
static <T> java.util.stream.Collector<T,?,java.util.SortedSet<T>> defaultCollector()
```
 - immutableCollector
```
static <T> java.util.stream.Collector<T,?,java.util.SortedSet<T>> immutableCollector()
```
 - empty
```
static <T> SortedSetX<T> empty()
```
 - of
```
static <T> SortedSetX<T> of(T... values)
```
 - singleton
```
static <T> SortedSetX<T> singleton(T value)
```
 - fromIterable
```
static <T> SortedSetX<T> fromIterable(java.lang.Iterable<T> it)
```
 - fromIterable
```
static <T> SortedSetX<T> fromIterable(java.util.stream.Collector<T,?,java.util.SortedSet<T>> collector,
 java.lang.Iterable<T> it)
```
 - toSortedSetX
```
default SortedSetX<T> toSortedSetX()
```
 Specified by:
 
 toSortedSetX in interface ConvertableSequence<T>
 - combine
```
default SortedSetX<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
 java.util.function.BinaryOperator<T> op)
```
 Combine two adjacent elements in a SortedSetX using the supplied BinaryOperator This is a stateful grouping & reduction operation. The output of a combination may in turn be combined with it's neighbor
```
 
 SortedSetX.of(1,1,2,3)
 .combine((a, b)->a.equals(b),Semigroups.intSum)
 .toListX()
 
 //ListX(3,4) 
 
```
 Specified by:
 
 combine in interface CollectionX<T>
 
 Specified by:
 
 combine in interface MutableCollectionX<T>
 
 Specified by:
 
 combine in interface Traversable<T>
 
 Parameters:
 
 predicate - Test to see if two neighbors should be joined
 
 op - Reducer to combine neighbors
 
 Returns:
 
 Combined / Partially Reduced SortedSetX
 - unit
```
default <R> SortedSetX<R> unit(R value)
```
 Specified by:
 
 unit in interface Unit<T>
 - unit
```
default <R> SortedSetX<R> unit(java.util.Collection<R> col)
```
 Specified by:
 
 unit in interface FluentCollectionX<T>
 - unitIterator
```
default <R> SortedSetX<R> unitIterator(java.util.Iterator<R> it)
```
 Specified by:
 
 unitIterator in interface IterableFunctor<T>
 - stream
```
default ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface java.util.Collection<T>
 
 Specified by:
 
 stream in interface CollectionX<T>
 
 Specified by:
 
 stream in interface ConvertableSequence<T>
 
 Specified by:
 
 stream in interface Foldable<T>
 
 Specified by:
 
 stream in interface IterableCollectable<T>
 
 Specified by:
 
 stream in interface IterableFunctor<T>
 
 Specified by:
 
 stream in interface Traversable<T>
 - from
```
default <T1> SortedSetX<T1> from(java.util.Collection<T1> c)
```
 Specified by:
 
 from in interface CollectionX<T>
 - getCollector
```
<T> java.util.stream.Collector<T,?,java.util.SortedSet<T>> getCollector()
```
 - fromStream
```
default <X> SortedSetX<X> fromStream(java.util.stream.Stream<X> stream)
```
 Specified by:
 
 fromStream in interface MutableCollectionX<T>
 - reverse
```
default SortedSetX<T> reverse()
```
 Specified by:
 
 reverse in interface CollectionX<T>
 
 Specified by:
 
 reverse in interface MutableCollectionX<T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 - filter
```
default SortedSetX<T> filter(java.util.function.Predicate<? super T> pred)
```
 Specified by:
 
 filter in interface CollectionX<T>
 
 Specified by:
 
 filter in interface Filterable<T>
 
 Specified by:
 
 filter in interface MutableCollectionX<T>
 - map
```
default <R> SortedSetX<R> map(java.util.function.Function<? super T,? extends R> mapper)
```
 Specified by:
 
 map in interface CollectionX<T>
 
 Specified by:
 
 map in interface Functor<T>
 
 Specified by:
 
 map in interface IterableFunctor<T>
 
 Specified by:
 
 map in interface MutableCollectionX<T>
 - flatMap
```
default <R> SortedSetX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
```
 Specified by:
 
 flatMap in interface CollectionX<T>
 
 Specified by:
 
 flatMap in interface MutableCollectionX<T>
 - limit
```
default SortedSetX<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 CollectionX<T>
 
 Specified by:
 
 limit in interface MutableCollectionX<T>
 
 Specified by:
 
 limit in interface Traversable<T>
 
 Parameters:
 
 num - Limit element size to num
 
 Returns:
 
 Monad converted to Stream with elements up to num
 - skip
```
default SortedSetX<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 CollectionX<T>
 
 Specified by:
 
 skip in interface MutableCollectionX<T>
 
 Specified by:
 
 skip in interface Traversable<T>
 
 Parameters:
 
 num - Number of elemenets to skip
 
 Returns:
 
 Stream with specified number of elements skipped
 - takeWhile
```
default SortedSetX<T> takeWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 takeWhile in interface CollectionX<T>
 
 Specified by:
 
 takeWhile in interface MutableCollectionX<T>
 
 Specified by:
 
 takeWhile in interface Traversable<T>
 - dropWhile
```
default SortedSetX<T> dropWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 dropWhile in interface CollectionX<T>
 
 Specified by:
 
 dropWhile in interface MutableCollectionX<T>
 
 Specified by:
 
 dropWhile in interface Traversable<T>
 - takeUntil
```
default SortedSetX<T> takeUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 takeUntil in interface CollectionX<T>
 
 Specified by:
 
 takeUntil in interface MutableCollectionX<T>
 
 Specified by:
 
 takeUntil in interface Traversable<T>
 - dropUntil
```
default SortedSetX<T> dropUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 dropUntil in interface CollectionX<T>
 
 Specified by:
 
 dropUntil in interface MutableCollectionX<T>
 
 Specified by:
 
 dropUntil in interface Traversable<T>
 - takeRight
```
default SortedSetX<T> takeRight(int num)
```
 Specified by:
 
 takeRight in interface CollectionX<T>
 
 Specified by:
 
 takeRight in interface MutableCollectionX<T>
 
 Specified by:
 
 takeRight in interface Traversable<T>
 - dropRight
```
default SortedSetX<T> dropRight(int num)
```
 Specified by:
 
 dropRight in interface CollectionX<T>
 
 Specified by:
 
 dropRight in interface MutableCollectionX<T>
 
 Specified by:
 
 dropRight in interface Traversable<T>
 - trampoline
```
default <R> SortedSetX<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
```
 Description copied from interface: MutableCollectionX
 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 CollectionX<T>
 
 Specified by:
 
 trampoline in interface Functor<T>
 
 Specified by:
 
 trampoline in interface MutableCollectionX<T>
 
 Returns:
 - slice
```
default SortedSetX<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface CollectionX<T>
 
 Specified by:
 
 slice in interface MutableCollectionX<T>
 
 Specified by:
 
 slice in interface Traversable<T>
 - sorted
```
default > SortedSetX<T> sorted(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 sorted in interface CollectionX<T>
 
 Specified by:
 
 sorted in interface MutableCollectionX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 - grouped
```
default SortedSetX<ListX<T>> grouped(int groupSize)
```
 Description copied from interface: Traversable
 Group elements in a Stream
```
 {
 @code
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(4, 5, 6));
 
 }
 
```
 Specified by:
 
 grouped in interface CollectionX<T>
 
 Specified by:
 
 grouped in interface MutableCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - grouped
```
default <K,A,D> SortedSetX<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)
```
 Specified by:
 
 grouped in interface CollectionX<T>
 
 Specified by:
 
 grouped in interface MutableCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 - grouped
```
default <K> SortedSetX<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
```
 Specified by:
 
 grouped in interface CollectionX<T>
 
 Specified by:
 
 grouped in interface MutableCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 - zip
```
default  SortedSetX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable other)
```
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface MutableCollectionX<T>
 - zip
```
default <U,R> SortedSetX<R> zip(java.lang.Iterable other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface MutableCollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 - sliding
```
default SortedSetX<ListX<T>> sliding(int windowSize)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 {
 @code
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(2).collect(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2));
 assertThat(list.get(1), hasItems(2, 3));
 
 }
 
 
```
 Specified by:
 
 sliding in interface CollectionX<T>
 
 Specified by:
 
 sliding in interface MutableCollectionX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - Size of sliding window
 
 Returns:
 
 SequenceM with sliding view
 - sliding
```
default SortedSetX<ListX<T>> sliding(int windowSize,
 int increment)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 {
 @code
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(3, 4, 5));
 
 }
 
 
```
 Specified by:
 
 sliding in interface CollectionX<T>
 
 Specified by:
 
 sliding in interface MutableCollectionX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - number of elements in each batch
 
 increment - for each window
 
 Returns:
 
 SequenceM with sliding view
 - scanLeft
```
default SortedSetX<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 CollectionX<T>
 
 Specified by:
 
 scanLeft in interface MutableCollectionX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Returns:
 - scanLeft
```
default  SortedSetX scanLeft(U seed,
 java.util.function.BiFunction<U,? super T,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 CollectionX<T>
 
 Specified by:
 
 scanLeft in interface MutableCollectionX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 - scanRight
```
default SortedSetX<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 CollectionX<T>
 
 Specified by:
 
 scanRight in interface MutableCollectionX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - scanRight
```
default  SortedSetX scanRight(U identity,
 java.util.function.BiFunction<? super T,U,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 CollectionX<T>
 
 Specified by:
 
 scanRight in interface MutableCollectionX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - plus
```
default SortedSetX<T> plus(T e)
```
 Specified by:
 
 plus in interface FluentCollectionX<T>
 
 Specified by:
 
 plus in interface MutableCollectionX<T>
 - plusAll
```
default SortedSetX<T> plusAll(java.util.Collection<? extends T> list)
```
 Specified by:
 
 plusAll in interface FluentCollectionX<T>
 
 Specified by:
 
 plusAll in interface MutableCollectionX<T>
 - minus
```
default SortedSetX<T> minus(java.lang.Object e)
```
 Specified by:
 
 minus in interface FluentCollectionX<T>
 
 Specified by:
 
 minus in interface MutableCollectionX<T>
 - minusAll
```
default SortedSetX<T> minusAll(java.util.Collection<?> list)
```
 Specified by:
 
 minusAll in interface FluentCollectionX<T>
 
 Specified by:
 
 minusAll in interface MutableCollectionX<T>
 - cycle
```
default ListX<T> cycle(int times)
```
 Description copied from interface: Traversable
 Convert to a Stream with the values repeated specified times
```
 
 		ReactiveSeq.of(1,2,2)
 								.cycle(3)
 								.collect(Collectors.toList());
 								
 		//List[1,2,2,1,2,2,1,2,2]
 
 
 
```
 Specified by:
 
 cycle in interface MutableCollectionX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 times - Times values should be repeated within a Stream
 
 Returns:
 
 Stream with values repeated
 - cycle
```
default ListX<T> cycle(Monoid<T> m,
 int 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(Collectors.toList());
 //List[3,3,3];
 
 
```
 Specified by:
 
 cycle in interface MutableCollectionX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 m - Monoid to be used in reduction
 
 times - Number of times value should be repeated
 
 Returns:
 
 Stream with reduced values repeated
 - cycleWhile
```
default ListX<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Repeat in a Stream while specified predicate holds
```
 {
 @code
 MutableInt count = MutableInt.of(0);
 ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6).collect(Collectors.toList());
 
 // List(1,2,2,1,2,2)
 }
 
```
 Specified by:
 
 cycleWhile in interface MutableCollectionX<T>
 
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - cycleUntil
```
default ListX<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(Collectors.toList());
 
 		//List[1,2,2,1,2,2,1]	
 
```
 Specified by:
 
 cycleUntil in interface MutableCollectionX<T>
 
 Specified by:
 
 cycleUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - zipStream
```
default  SortedSetX<org.jooq.lambda.tuple.Tuple2<T,U>> zipStream(java.util.stream.Stream other)
```
 Description copied from interface: Traversable
 Zip 2 streams into one
```
 {
 @code
 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
 // [[1,"a"],[2,"b"]]
 }
 
```
 Specified by:
 
 zipStream in interface CollectionX<T>
 
 Specified by:
 
 zipStream in interface MutableCollectionX<T>
 
 Specified by:
 
 zipStream in interface Traversable<T>
 - zip
```
default  SortedSetX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq other)
```
 Description copied from interface: Traversable
 Zip 2 streams into one
```
 {
 @code
 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
 // [[1,"a"],[2,"b"]]
 }
 
```
 Specified by:
 
 zip in interface MutableCollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 - zip3
```
default <S,U> SortedSetX<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second,
 java.util.stream.Stream<? extends U> third)
```
 Description copied from interface: Traversable
 zip 3 Streams into one
```
 {
 @code
 List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(Collectors.toList());
 
 // [[1,100,'a'],[2,200,'b'],[3,300,'c']]
 }
 
 
```
 Specified by:
 
 zip3 in interface MutableCollectionX<T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 - zip4
```
default <T2,T3,T4> SortedSetX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<T2> second,
 java.util.stream.Stream<T3> third,
 java.util.stream.Stream<T4> fourth)
```
 Description copied from interface: Traversable
 zip 4 Streams into 1
```
 {
 @code
 List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
 .collect(Collectors.toList());
 
 }
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 
```
 Specified by:
 
 zip4 in interface MutableCollectionX<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 - zipWithIndex
```
default SortedSetX<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 CollectionX<T>
 
 Specified by:
 
 zipWithIndex in interface MutableCollectionX<T>
 
 Specified by:
 
 zipWithIndex in interface Traversable<T>
 - distinct
```
default SortedSetX<T> distinct()
```
 Specified by:
 
 distinct in interface CollectionX<T>
 
 Specified by:
 
 distinct in interface MutableCollectionX<T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 - sorted
```
default SortedSetX<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 CollectionX<T>
 
 Specified by:
 
 sorted in interface MutableCollectionX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 - sorted
```
default SortedSetX<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 CollectionX<T>
 
 Specified by:
 
 sorted in interface MutableCollectionX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Parameters:
 
 c - Compartor to sort with
 
 Returns:
 
 Sorted Stream
 - skipWhile
```
default SortedSetX<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 MutableCollectionX<T>
 
 Specified by:
 
 skipWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to skip while true
 
 Returns:
 
 Stream with elements skipped while predicate holds
 - skipUntil
```
default SortedSetX<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 MutableCollectionX<T>
 
 Specified by:
 
 skipUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to skip until true
 
 Returns:
 
 Stream with elements skipped until predicate holds
 - limitWhile
```
default SortedSetX<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 MutableCollectionX<T>
 
 Specified by:
 
 limitWhile in interface Traversable<T>
 
 Parameters:
 
 p - Limit while predicate is true
 
 Returns:
 
 Stream with limited elements
 - limitUntil
```
default SortedSetX<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 MutableCollectionX<T>
 
 Specified by:
 
 limitUntil in interface Traversable<T>
 
 Parameters:
 
 p - Limit until predicate is true
 
 Returns:
 
 Stream with limited elements
 - intersperse
```
default SortedSetX<T> intersperse(T value)
```
 Description copied from interface: Traversable
 
 Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) ReactiveSeq.of(1, 2, 3, 4).intersperse(0)
 
 Specified by:
 
 intersperse in interface MutableCollectionX<T>
 
 Specified by:
 
 intersperse in interface Traversable<T>
 - shuffle
```
default SortedSetX<T> shuffle()
```
 Specified by:
 
 shuffle in interface MutableCollectionX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - skipLast
```
default SortedSetX<T> skipLast(int num)
```
 Description copied from interface: Traversable
 
 assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
 
 Specified by:
 
 skipLast in interface MutableCollectionX<T>
 
 Specified by:
 
 skipLast in interface Traversable<T>
 
 Returns:
 - limitLast
```
default SortedSetX<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(Collectors.toList()),equalTo(Arrays.asList(4,5)));
 
 
```
 Specified by:
 
 limitLast in interface MutableCollectionX<T>
 
 Specified by:
 
 limitLast in interface Traversable<T>
 
 Parameters:
 
 num - of elements to return (last elements)
 
 Returns:
 
 SequenceM limited to last num elements
 - onEmpty
```
default SortedSetX<T> onEmpty(T value)
```
 Specified by:
 
 onEmpty in interface MutableCollectionX<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 - onEmptyGet
```
default SortedSetX<T> onEmptyGet(java.util.function.Supplier<T> supplier)
```
 Specified by:
 
 onEmptyGet in interface MutableCollectionX<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 - onEmptyThrow
```
default <X extends java.lang.Throwable> SortedSetX<T> onEmptyThrow(java.util.function.Supplier<X> supplier)
```
 Specified by:
 
 onEmptyThrow in interface MutableCollectionX<T>
 
 Specified by:
 
 onEmptyThrow in interface Traversable<T>
 - shuffle
```
default SortedSetX<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface MutableCollectionX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - ofType
```
default  SortedSetX ofType(java.lang.Class type)
```
 Description copied from interface: Filterable
 
 Keep only those elements in a stream that are of a given type. // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
 
 Specified by:
 
 ofType in interface Filterable<T>
 
 Specified by:
 
 ofType in interface MutableCollectionX<T>
 - filterNot
```
default SortedSetX<T> filterNot(java.util.function.Predicate<? super T> fn)
```
 Specified by:
 
 filterNot in interface CollectionX<T>
 
 Specified by:
 
 filterNot in interface Filterable<T>
 
 Specified by:
 
 filterNot in interface MutableCollectionX<T>
 - notNull
```
default SortedSetX<T> notNull()
```
 Specified by:
 
 notNull in interface CollectionX<T>
 
 Specified by:
 
 notNull in interface Filterable<T>
 
 Specified by:
 
 notNull in interface MutableCollectionX<T>
 - removeAll
```
default SortedSetX<T> removeAll(java.util.stream.Stream<T> stream)
```
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Specified by:
 
 removeAll in interface MutableCollectionX<T>
 - removeAll
```
default SortedSetX<T> removeAll(java.lang.Iterable<T> it)
```
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Specified by:
 
 removeAll in interface MutableCollectionX<T>
 - removeAll
```
default SortedSetX<T> removeAll(T... values)
```
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Specified by:
 
 removeAll in interface MutableCollectionX<T>
 - retainAll
```
default SortedSetX<T> retainAll(java.lang.Iterable<T> it)
```
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Specified by:
 
 retainAll in interface MutableCollectionX<T>
 - retainAll
```
default SortedSetX<T> retainAll(java.util.stream.Stream<T> stream)
```
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Specified by:
 
 retainAll in interface MutableCollectionX<T>
 - retainAll
```
default SortedSetX<T> retainAll(T... values)
```
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Specified by:
 
 retainAll in interface MutableCollectionX<T>
 - cast
```
default  SortedSetX cast(java.lang.Class type)
```
 Description copied from interface: Functor
 
 Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)
 
 Specified by:
 
 cast in interface CollectionX<T>
 
 Specified by:
 
 cast in interface Functor<T>
 
 Specified by:
 
 cast in interface MutableCollectionX<T>
 - patternMatch
```
default <R> SortedSetX<R> patternMatch(java.util.function.Function<Matchable.CheckValues<T,R>,Matchable.CheckValues<T,R>> case1,
 java.util.function.Supplier<? extends R> otherwise)
```
 Description copied from interface: Functor
 Transform the elements of this Stream with a Pattern Matching case and default value
```
 
 List<String> result = CollectionX.of(1,2,3,4)
 .patternMatch(
 c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
 )
 
 // CollectionX["odd","even","odd","even"]
 
```
 Specified by:
 
 patternMatch in interface CollectionX<T>
 
 Specified by:
 
 patternMatch in interface Functor<T>
 
 Specified by:
 
 patternMatch in interface MutableCollectionX<T>
 
 Parameters:
 
 case1 - Function to generate a case (or chain of cases as a single case)
 
 otherwise - Value if supplied case doesn't match
 
 Returns:
 
 CollectionX where elements are transformed by pattern matching
 - grouped
```
default <C extends java.util.Collection<? super T>> SortedSetX<C> grouped(int size,
 java.util.function.Supplier<C> supplier)
```
 Description copied from interface: Traversable
 Batch elements in a Stream by size into a collection created by the supplied factory
```
 
 assertThat(ReactiveSeq.of(1,1,1,1,1,1)
 .batchBySize(3,()->new TreeSet<>())
 .toList()
 .get(0)
 .size(),is(1));
 
```
 Specified by:
 
 grouped in interface MutableCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 SequenceM batched into collection types by size
 - groupedUntil
```
default SortedSetX<ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Create a SequenceM batched by List, where each batch is populated until the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .batchUntil(i->i%3==0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedUntil in interface MutableCollectionX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedWhile
```
default SortedSetX<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Create a SequenceM 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 MutableCollectionX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedWhile
```
default <C extends java.util.Collection<? super T>> SortedSetX<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 MutableCollectionX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - groupedUntil
```
default <C extends java.util.Collection<? super T>> SortedSetX<C> groupedUntil(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 until the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .batchUntil(i->i%3!=0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedUntil in interface MutableCollectionX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - groupedStatefullyWhile
```
default SortedSetX<ListX<T>> groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
```
 Description copied from interface: Traversable
 Create SequenceM of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied bipredicate holds. The bipredicate recieves the Streamable 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)
 .windowStatefullyWhile((s,i)->s.sequenceM().toList().contains(4) ? true : false)
 .toList().size(),equalTo(5));
 
 
```
 Specified by:
 
 groupedStatefullyWhile in interface MutableCollectionX<T>
 
 Specified by:
 
 groupedStatefullyWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 SequenceM windowed while predicate holds
 - removeAll
```
default SortedSetX<T> removeAll(org.jooq.lambda.Seq<T> stream)
```
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Specified by:
 
 removeAll in interface MutableCollectionX<T>
 - retainAll
```
default SortedSetX<T> retainAll(org.jooq.lambda.Seq<T> stream)
```
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface MutableCollectionX<T>
 - permutations
```
default SortedSetX<ReactiveSeq<T>> permutations()
```
 Description copied from interface: ExtendedTraversable
 
 Generate the permutations based on values in the SequenceM Makes use of Streamable to store intermediate stages in a collection
 
 Specified by:
 
 permutations in interface CollectionX<T>
 
 Specified by:
 
 permutations in interface ExtendedTraversable<T>
 
 Specified by:
 
 permutations in interface MutableCollectionX<T>
 
 Returns:
 
 Permutations from this SequenceM
 - combinations
```
default SortedSetX<ReactiveSeq<T>> combinations(int size)
```
 Description copied from interface: ExtendedTraversable
```
 
 ReactiveSeq.of(1,2,3).combinations(2)
 
 //SequenceM[SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]]
 
 
```
 Specified by:
 
 combinations in interface CollectionX<T>
 
 Specified by:
 
 combinations in interface ExtendedTraversable<T>
 
 Specified by:
 
 combinations in interface MutableCollectionX<T>
 
 Parameters:
 
 size - of combinations
 
 Returns:
 
 All combinations of the elements in this stream of the specified size
 - combinations
```
default SortedSetX<ReactiveSeq<T>> combinations()
```
 Description copied from interface: ExtendedTraversable
```
 
 ReactiveSeq.of(1,2,3).combinations()
 
 //SequenceM[SequenceM[],SequenceM[1],SequenceM[2],SequenceM[3].SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]
 			,SequenceM[1,2,3]]
 
 
```
 Specified by:
 
 combinations in interface CollectionX<T>
 
 Specified by:
 
 combinations in interface ExtendedTraversable<T>
 
 Specified by:
 
 combinations in interface MutableCollectionX<T>
 
 Returns:
 
 All combinations of the elements in this stream

Interface SortedSetX<T>

Nested Class Summary

Method Summary

Methods inherited from interface java.util.SortedSet

Methods inherited from interface java.util.Set

Methods inherited from interface com.aol.cyclops.data.collections.extensions.FluentCollectionX

Methods inherited from interface com.aol.cyclops.data.collections.extensions.CollectionX

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

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

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

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

Methods inherited from interface java.util.Collection

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

Methods inherited from interface org.jooq.lambda.Collectable

Method Detail

defaultCollector

immutableCollector

empty

of

singleton

fromIterable

fromIterable

toSortedSetX

combine

unit

unit

unitIterator

stream

from

getCollector

fromStream

reverse

filter

map

flatMap

limit

skip

takeWhile

dropWhile

takeUntil

dropUntil

takeRight

dropRight

trampoline

slice

sorted

grouped

grouped

grouped

zip

zip

sliding

sliding

scanLeft

scanLeft

scanRight

scanRight

plus

plusAll

minus

minusAll

cycle

cycle

cycleWhile

cycleUntil

zipStream

zip

zip3

zip4

zipWithIndex

distinct

sorted

sorted

skipWhile

skipUntil

limitWhile

limitUntil

intersperse

shuffle

skipLast