PersistentCollectionX (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>, org.reactivestreams.Publisher<T>, Sequential<T>, Traversable<T>, Unit<T>, ZippingApplicativable<T>

All Known Subinterfaces:

PBagX<T>, POrderedSetX<T>, PQueueX<T>, PSetX<T>, PStackX<T>, PVectorX<T>

All Known Implementing Classes:

PBagXImpl, POrderedSetXImpl, PQueueXImpl, PSetXImpl, PStackXImpl, PVectorXImpl
```
public interface PersistentCollectionX<T>
extends FluentCollectionX<T>
```

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <U> PersistentCollectionX<U>`	`cast(java.lang.Class<U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default PersistentCollectionX<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 PersistentCollectionX<ReactiveSeq<T>>`	`combinations(int size)` `ReactiveSeq.of(1,2,3).combinations(2) //SequenceM[SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]]`
`default PersistentCollectionX<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 & reduction operation.
`default PersistentCollectionX<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`default PersistentCollectionX<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`default PersistentCollectionX<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`default PersistentCollectionX<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`default PersistentCollectionX<T>`	`distinct()`
`default PersistentCollectionX<T>`	`dropRight(int num)`
`default PersistentCollectionX<T>`	`dropUntil(java.util.function.Predicate<? super T> p)`
`default PersistentCollectionX<T>`	`dropWhile(java.util.function.Predicate<? super T> p)`
`<R> PersistentCollectionX<R>`	`emptyUnit()`
`default PersistentCollectionX<T>`	`filter(java.util.function.Predicate<? super T> pred)`
`default PersistentCollectionX<T>`	`filterNot(java.util.function.Predicate<? super T> fn)`
`default <R> PersistentCollectionX<R>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)`
`<T1> PersistentCollectionX<T1>`	`from(java.util.Collection<T1> c)`
`default <K> PersistentCollectionX<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> PersistentCollectionX<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 PersistentCollectionX<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`default <C extends java.util.Collection<? super T>> PersistentCollectionX<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 PersistentCollectionX<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 PersistentCollectionX<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>> PersistentCollectionX<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 PersistentCollectionX<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>> PersistentCollectionX<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 PersistentCollectionX<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`default PersistentCollectionX<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`default PersistentCollectionX<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`default PersistentCollectionX<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 PersistentCollectionX<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> PersistentCollectionX<R>`	`map(java.util.function.Function<? super T,? extends R> mapper)`
`<T> Reducer<? extends java.util.Collection<T>>`	`monoid()`
`default PersistentCollectionX<T>`	`notNull()`
`default <U> PersistentCollectionX<U>`	`ofType(java.lang.Class<U> type)` Keep only those elements in a stream that are of a given type.
`default PersistentCollectionX<T>`	`onEmpty(T value)`
`default PersistentCollectionX<T>`	`onEmptyGet(java.util.function.Supplier<T> supplier)`
`default <X extends java.lang.Throwable> PersistentCollectionX<T>`	`onEmptyThrow(java.util.function.Supplier<X> supplier)`
`default <R> PersistentCollectionX<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 PersistentCollectionX<ReactiveSeq<T>>`	`permutations()` Generate the permutations based on values in the SequenceM Makes use of Streamable to store intermediate stages in a collection
`default PersistentCollectionX<T>`	`plusInOrder(T e)`
`default PersistentCollectionX<T>`	`removeAll(java.lang.Iterable<T> it)`
`default PersistentCollectionX<T>`	`removeAll(org.jooq.lambda.Seq<T> stream)`
`default PersistentCollectionX<T>`	`removeAll(java.util.stream.Stream<T> stream)`
`default PersistentCollectionX<T>`	`removeAll(T... values)`
`default PersistentCollectionX<T>`	`retainAll(java.lang.Iterable<T> it)`
`default PersistentCollectionX<T>`	`retainAll(org.jooq.lambda.Seq<T> stream)`
`default PersistentCollectionX<T>`	`retainAll(java.util.stream.Stream<T> stream)`
`default PersistentCollectionX<T>`	`retainAll(T... values)`
`default CollectionX<T>`	`reverse()`
`default PersistentCollectionX<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`default <U> PersistentCollectionX<U>`	`scanLeft(U seed, java.util.function.BiFunction<U,? super T,U> function)` Scan left
`default PersistentCollectionX<T>`	`scanRight(Monoid<T> monoid)` Scan right
`default <U> PersistentCollectionX<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,U,U> combiner)` Scan right
`default PersistentCollectionX<T>`	`shuffle()`
`default PersistentCollectionX<T>`	`shuffle(java.util.Random random)`
`default PersistentCollectionX<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`default PersistentCollectionX<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`default PersistentCollectionX<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 PersistentCollectionX<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 PersistentCollectionX<T>`	`slice(long from, long to)`
`default PersistentCollectionX<ListX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`default PersistentCollectionX<ListX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`default PersistentCollectionX<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`default PersistentCollectionX<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>> PersistentCollectionX<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`default ReactiveSeq<T>`	`stream()`
`default PersistentCollectionX<T>`	`takeRight(int num)`
`default PersistentCollectionX<T>`	`takeUntil(java.util.function.Predicate<? super T> p)`
`default PersistentCollectionX<T>`	`takeWhile(java.util.function.Predicate<? super T> p)`
`default <R> PersistentCollectionX<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> PersistentCollectionX<R>`	`unit(java.util.Collection<R> col)`
`default <U> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<U> other)`
`default <U,R> PersistentCollectionX<R>`	`zip(java.lang.Iterable<U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <U> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<U> other)` Zip 2 streams into one
`default <S,U> PersistentCollectionX<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> PersistentCollectionX<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> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipStream(java.util.stream.Stream<U> other)` Zip 2 streams into one
`default PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream

Methods inherited from interface com.aol.cyclops.data.collections.extensions.FluentCollectionX
minus, minusAll, plus, plusAll

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, unitIterator

Methods inherited from interface com.aol.cyclops.types.Unit
unit

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

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

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>

plusInOrder
```
default PersistentCollectionX<T> plusInOrder(T e)
```
Specified by:

plusInOrder in interface FluentCollectionX<T>

unit

<R> PersistentCollectionX<R> unit(java.util.Collection<R> col)

Specified by:: unit in interface FluentCollectionX<T>

emptyUnit

<R> PersistentCollectionX<R> emptyUnit()

monoid

<T> Reducer<? extends java.util.Collection<T>> monoid()

from

<T1> PersistentCollectionX<T1> from(java.util.Collection<T1> c)

Specified by:: from in interface CollectionX<T>

reverse
```
default CollectionX<T> reverse()
```
Specified by:

reverse in interface CollectionX<T>

Specified by:

reverse in interface Traversable<T>

filter
```
default PersistentCollectionX<T> filter(java.util.function.Predicate<? super T> pred)
```
Specified by:

filter in interface CollectionX<T>

Specified by:

filter in interface Filterable<T>

map
```
default <R> PersistentCollectionX<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>

flatMap

default <R> PersistentCollectionX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)

Specified by:: flatMap in interface CollectionX<T>

limit
```
default PersistentCollectionX<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 Traversable<T>

Parameters:

num - Limit element size to num

Returns:

Monad converted to Stream with elements up to num

skip
```
default PersistentCollectionX<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 Traversable<T>

Parameters:

num - Number of elemenets to skip

Returns:

Stream with specified number of elements skipped

dropRight
```
default PersistentCollectionX<T> dropRight(int num)
```
Specified by:

dropRight in interface CollectionX<T>

Specified by:

dropRight in interface Traversable<T>

takeRight
```
default PersistentCollectionX<T> takeRight(int num)
```
Specified by:

takeRight in interface CollectionX<T>

Specified by:

takeRight in interface Traversable<T>

takeWhile
```
default PersistentCollectionX<T> takeWhile(java.util.function.Predicate<? super T> p)
```
Specified by:

takeWhile in interface CollectionX<T>

Specified by:

takeWhile in interface Traversable<T>

dropWhile
```
default PersistentCollectionX<T> dropWhile(java.util.function.Predicate<? super T> p)
```
Specified by:

dropWhile in interface CollectionX<T>

Specified by:

dropWhile in interface Traversable<T>

takeUntil
```
default PersistentCollectionX<T> takeUntil(java.util.function.Predicate<? super T> p)
```
Specified by:

takeUntil in interface CollectionX<T>

Specified by:

takeUntil in interface Traversable<T>

dropUntil
```
default PersistentCollectionX<T> dropUntil(java.util.function.Predicate<? super T> p)
```
Specified by:

dropUntil in interface CollectionX<T>

Specified by:

dropUntil in interface Traversable<T>

trampoline

default <R> PersistentCollectionX<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

 
 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>
Parameters:: mapper -
Returns:

slice

default PersistentCollectionX<T> slice(long from,
                                       long to)

Specified by:: slice in interface CollectionX<T>
Specified by:: slice in interface Traversable<T>

sorted

default <U extends java.lang.Comparable<? super U>> PersistentCollectionX<T> sorted(java.util.function.Function<? super T,? extends U> function)

Specified by:: sorted in interface CollectionX<T>
Specified by:: sorted in interface Traversable<T>

grouped

default PersistentCollectionX<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 Traversable<T>
Parameters:: groupSize - Size of each Group
Returns:: Stream with elements grouped by size

grouped

default <K,A,D> PersistentCollectionX<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 Traversable<T>

grouped

default <K> PersistentCollectionX<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 Traversable<T>

zip

default <U> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<U> other)

Specified by:: zip in interface CollectionX<T>

zip

default <U,R> PersistentCollectionX<R> zip(java.lang.Iterable<U> other,
                                           java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Specified by:: zip in interface CollectionX<T>
Specified by:: zip in interface Traversable<T>

sliding

default PersistentCollectionX<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 Traversable<T>
Parameters:: windowSize - Size of sliding window
Returns:: SequenceM with sliding view

sliding

default PersistentCollectionX<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 Traversable<T>
Parameters:: windowSize - number of elements in each batch; increment - for each window
Returns:: SequenceM with sliding view

scanLeft

default PersistentCollectionX<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 Traversable<T>
Returns:

scanRight

default PersistentCollectionX<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 Traversable<T>

scanLeft

default <U> PersistentCollectionX<U> 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 Traversable<T>

scanRight

default <U> PersistentCollectionX<U> 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 Traversable<T>

cycle
```
default PersistentCollectionX<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 Traversable<T>

Parameters:

times - Times values should be repeated within a Stream

Returns:

Stream with values repeated

cycle

default PersistentCollectionX<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 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 PersistentCollectionX<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 Traversable<T>
Parameters:: predicate - repeat while true
Returns:: Repeating Stream

cycleUntil

default PersistentCollectionX<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 Traversable<T>
Parameters:: predicate - repeat while true
Returns:: Repeating Stream

zipStream

default <U> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zipStream(java.util.stream.Stream<U> 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 Traversable<T>

zip

default <U> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<U> 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 Traversable<T>

zip3

default <S,U> PersistentCollectionX<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 Traversable<T>

zip4

default <T2,T3,T4> PersistentCollectionX<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 Traversable<T>

zipWithIndex

default PersistentCollectionX<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 Traversable<T>

distinct
```
default PersistentCollectionX<T> distinct()
```
Specified by:

distinct in interface CollectionX<T>

Specified by:

distinct in interface Traversable<T>

sorted

default PersistentCollectionX<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 Traversable<T>

sorted
```
default PersistentCollectionX<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 Traversable<T>

Parameters:

c - Compartor to sort with

Returns:

Sorted Stream

skipWhile
```
default PersistentCollectionX<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
```
default PersistentCollectionX<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

limitWhile
```
default PersistentCollectionX<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
```
default PersistentCollectionX<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

intersperse
```
default PersistentCollectionX<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 Traversable<T>

shuffle
```
default PersistentCollectionX<T> shuffle()
```
Specified by:

shuffle in interface Traversable<T>

skipLast
```
default PersistentCollectionX<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 Traversable<T>

Returns:

limitLast
```
default PersistentCollectionX<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 Traversable<T>

Parameters:

num - of elements to return (last elements)

Returns:

SequenceM limited to last num elements

onEmpty

default PersistentCollectionX<T> onEmpty(T value)

Specified by:: onEmpty in interface Traversable<T>

onEmptyGet

default PersistentCollectionX<T> onEmptyGet(java.util.function.Supplier<T> supplier)

Specified by:: onEmptyGet in interface Traversable<T>

onEmptyThrow

default <X extends java.lang.Throwable> PersistentCollectionX<T> onEmptyThrow(java.util.function.Supplier<X> supplier)

Specified by:: onEmptyThrow in interface Traversable<T>

shuffle

default PersistentCollectionX<T> shuffle(java.util.Random random)

Specified by:: shuffle in interface Traversable<T>

ofType
```
default  PersistentCollectionX 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>

filterNot
```
default PersistentCollectionX<T> filterNot(java.util.function.Predicate<? super T> fn)
```
Specified by:

filterNot in interface CollectionX<T>

Specified by:

filterNot in interface Filterable<T>

notNull
```
default PersistentCollectionX<T> notNull()
```
Specified by:

notNull in interface CollectionX<T>

Specified by:

notNull in interface Filterable<T>

removeAll
```
default PersistentCollectionX<T> removeAll(java.util.stream.Stream<T> stream)
```
Specified by:

removeAll in interface CollectionX<T>

Specified by:

removeAll in interface IterableFilterable<T>

removeAll

default PersistentCollectionX<T> removeAll(org.jooq.lambda.Seq<T> stream)

Specified by:: removeAll in interface CollectionX<T>

removeAll
```
default PersistentCollectionX<T> removeAll(java.lang.Iterable<T> it)
```
Specified by:

removeAll in interface CollectionX<T>

Specified by:

removeAll in interface IterableFilterable<T>

removeAll
```
default PersistentCollectionX<T> removeAll(T... values)
```
Specified by:

removeAll in interface CollectionX<T>

Specified by:

removeAll in interface IterableFilterable<T>

retainAll
```
default PersistentCollectionX<T> retainAll(java.lang.Iterable<T> it)
```
Specified by:

retainAll in interface CollectionX<T>

Specified by:

retainAll in interface IterableFilterable<T>

retainAll
```
default PersistentCollectionX<T> retainAll(java.util.stream.Stream<T> stream)
```
Specified by:

retainAll in interface CollectionX<T>

Specified by:

retainAll in interface IterableFilterable<T>

retainAll

default PersistentCollectionX<T> retainAll(org.jooq.lambda.Seq<T> stream)

Specified by:: retainAll in interface CollectionX<T>

retainAll
```
default PersistentCollectionX<T> retainAll(T... values)
```
Specified by:

retainAll in interface CollectionX<T>

Specified by:

retainAll in interface IterableFilterable<T>

cast
```
default  PersistentCollectionX 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>

patternMatch

default <R> PersistentCollectionX<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>
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

permutations
```
default PersistentCollectionX<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>

Returns:

Permutations from this SequenceM

combinations
```
default PersistentCollectionX<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>

Parameters:

size - of combinations

Returns:

All combinations of the elements in this stream of the specified size

combinations

default PersistentCollectionX<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>
Returns:: All combinations of the elements in this stream

grouped

default <C extends java.util.Collection<? super T>> PersistentCollectionX<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 Traversable<T>
Parameters:: size - batch size; supplier - Collection factory
Returns:: SequenceM batched into collection types by size

groupedUntil
```
default PersistentCollectionX<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 Traversable<T>

Parameters:

predicate - Batch until predicate holds, then open next batch

Returns:

SequenceM batched into lists determined by the predicate supplied

groupedStatefullyWhile
```
default PersistentCollectionX<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 Traversable<T>

Parameters:

predicate - Window while true

Returns:

SequenceM windowed while predicate holds

combine
```
default PersistentCollectionX<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 & reduction operation. The output of a combination may in turn be combined with it's neighbour
```
 
 ReactiveSeq.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 Traversable<T>

Parameters:

predicate - Test to see if two neighbours should be joined

op - Reducer to combine neighbours

Returns:

Combined / Partially Reduced Traversable

groupedWhile
```
default PersistentCollectionX<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 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>> PersistentCollectionX<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, 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>> PersistentCollectionX<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 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

Interface PersistentCollectionX<T>

Method Summary

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 com.aol.cyclops.types.Unit

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

stream

plusInOrder

unit

emptyUnit

monoid

from

reverse

filter

map

flatMap

limit

skip

dropRight

takeRight

takeWhile

dropWhile

takeUntil

dropUntil

trampoline

slice

sorted

grouped

grouped

grouped

zip

zip

sliding

sliding

scanLeft

scanRight

scanLeft

scanRight

cycle

cycle

cycleWhile

cycleUntil

zipStream

zip

zip3

zip4

zipWithIndex

distinct

sorted

sorted

skipWhile

skipUntil

limitWhile

limitUntil

intersperse

shuffle

skipLast

limitLast

onEmpty

onEmptyGet

onEmptyThrow

shuffle

ofType

filterNot

notNull

removeAll

removeAll

removeAll

removeAll

retainAll

retainAll

retainAll

retainAll