CollectionX (simple-react 1.0.0-RC2.2 API)

All Superinterfaces:

org.jooq.lambda.Collectable<T>, java.util.Collection<T>, ConvertableSequence<T>, CyclopsCollectable<T>, ExtendedTraversable<T>, Filterable<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:

DequeX<T>, FluentCollectionX<T>, FluentSequenceX<T>, ListX<T>, MutableCollectionX<T>, MutableSequenceX<T>, PBagX<T>, PersistentCollectionX<T>, POrderedSetX<T>, PQueueX<T>, PSetX<T>, PStackX<T>, PVectorX<T>, QueueX<T>, SetX<T>, SortedSetX<T>

All Known Implementing Classes:

CollectionXImpl, DequeXImpl, ListXImpl, MaterializedList, PBagXImpl, POrderedSetXImpl, PQueueXImpl, PSetXImpl, PStackXImpl, PVectorXImpl, QueueXImpl, SetXImpl, SortedSetXImpl
```
public interface CollectionX<T>
extends ExtendedTraversable<T>, IterableCollectable<T>, java.lang.Iterable<T>, Sequential<T>, IterableFunctor<T>, Foldable<T>, IterableFilterable<T>, ZippingApplicativable<T>, Unit<T>, java.util.Collection<T>, CyclopsCollectable<T>
```

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <U> CollectionX<U>`	`cast(java.lang.Class<U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default CyclopsCollectable<T>`	`collectable()` Narrow this class to a Collectable
`CollectionX<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]]`
`CollectionX<ReactiveSeq<T>>`	`combinations(int size)` `ReactiveSeq.of(1,2,3).combinations(2) //SequenceM[SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]]`
`CollectionX<T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)` Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping & reduction operation.
`CollectionX<T>`	`distinct()`
`CollectionX<T>`	`dropRight(int num)`
`CollectionX<T>`	`dropUntil(java.util.function.Predicate<? super T> p)`
`CollectionX<T>`	`dropWhile(java.util.function.Predicate<? super T> p)`
`CollectionX<T>`	`filter(java.util.function.Predicate<? super T> pred)`
`CollectionX<T>`	`filterNot(java.util.function.Predicate<? super T> fn)`
`default java.util.Optional<T>`	`findAny()`
`default java.util.Optional<T>`	`findFirst()`
`<R> CollectionX<R>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)`
`default <R1,R> ReactiveSeq<R>`	`forEach2(java.util.function.Function<? super T,java.lang.Iterable<R1>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied stream
`default <R1,R> ReactiveSeq<R>`	`forEach2(java.util.function.Function<? super T,java.lang.Iterable<R1>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied stream
`default <R1,R2,R> ReactiveSeq<R>`	`forEach3(java.util.function.Function<? super T,java.lang.Iterable<R1>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Iterable<R2>>> stream2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`default <R1,R2,R> ReactiveSeq<R>`	`forEach3(java.util.function.Function<? super T,java.lang.Iterable<R1>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Iterable<R2>>> stream2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`<T1> CollectionX<T1>`	`from(java.util.Collection<T1> c)`
`static <T> CollectionX<T>`	`fromCollection(java.util.Collection<T> col)`
`default java.util.Optional<T>`	`getAtIndex(int index)`
`default <K> MapX<K,java.util.List<T>>`	`groupBy(java.util.function.Function<? super T,? extends K> classifier)` Use classifier function to group elements in this Sequence into a Map
`<K> CollectionX<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier)`
`<K,A,D> CollectionX<org.jooq.lambda.tuple.Tuple2<K,D>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)`
`CollectionX<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`default T`	`head()`
`default HeadAndTail<T>`	`headAndTail()` extract head and tail together, where head is expected to be present
`CollectionX<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`<R> CollectionX<R>`	`map(java.util.function.Function<? super T,? extends R> mapper)`
`CollectionX<T>`	`notNull()`
`default <R> CollectionX<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 CollectionX<T>`	`peek(java.util.function.Consumer<? super T> c)`
`CollectionX<ReactiveSeq<T>>`	`permutations()` Generate the permutations based on values in the SequenceM Makes use of Streamable to store intermediate stages in a collection
`CollectionX<T>`	`removeAll(java.lang.Iterable<T> it)`
`CollectionX<T>`	`removeAll(org.jooq.lambda.Seq<T> seq)`
`CollectionX<T>`	`removeAll(java.util.stream.Stream<T> stream)`
`CollectionX<T>`	`removeAll(T... values)`
`CollectionX<T>`	`retainAll(java.lang.Iterable<T> it)`
`CollectionX<T>`	`retainAll(org.jooq.lambda.Seq<T> seq)`
`CollectionX<T>`	`retainAll(java.util.stream.Stream<T> stream)`
`CollectionX<T>`	`retainAll(T... values)`
`CollectionX<T>`	`reverse()`
`CollectionX<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> CollectionX<U>`	`scanLeft(U seed, java.util.function.BiFunction<U,? super T,U> function)` Scan left
`CollectionX<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> CollectionX<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,U,U> combiner)` Scan right
`default T`	`single()` `//1 ReactiveSeq.of(1).single(); //UnsupportedOperationException ReactiveSeq.of().single(); //UnsupportedOperationException ReactiveSeq.of(1,2,3).single();`
`default T`	`single(java.util.function.Predicate<? super T> predicate)`
`default java.util.Optional<T>`	`singleOptional()` `//Optional[1] ReactiveSeq.of(1).singleOptional(); //Optional.empty ReactiveSeq.of().singleOpional(); //Optional.empty ReactiveSeq.of(1,2,3).singleOptional();`
`CollectionX<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`CollectionX<T>`	`slice(long from, long to)`
`CollectionX<ListX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`CollectionX<ListX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`CollectionX<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`CollectionX<T>`	`sorted(java.util.Comparator<? super T> c)` `assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));`
`<U extends java.lang.Comparable<? super U>> CollectionX<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`default ReactiveSeq<T>`	`stream()`
`CollectionX<T>`	`takeRight(int num)`
`CollectionX<T>`	`takeUntil(java.util.function.Predicate<? super T> p)`
`CollectionX<T>`	`takeWhile(java.util.function.Predicate<? super T> p)`
`<R> CollectionX<R>`	`trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`<U> CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<U> other)`
`<U,R> CollectionX<R>`	`zip(java.lang.Iterable<U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`<U> CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipStream(java.util.stream.Stream<U> other)` Zip 2 streams into one
`CollectionX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream

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.Filterable
ofType

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

fromCollection

static <T> CollectionX<T> fromCollection(java.util.Collection<T> col)

stream
```
default ReactiveSeq<T> stream()
```
Specified by:

stream in interface java.util.Collection<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>

collectable
```
default CyclopsCollectable<T> collectable()
```
Description copied from interface: CyclopsCollectable

Narrow this class to a Collectable

Specified by:

collectable in interface CyclopsCollectable<T>

Specified by:

collectable in interface IterableFunctor<T>

Returns:

Collectable

getAtIndex

default java.util.Optional<T> getAtIndex(int index)

headAndTail

default HeadAndTail<T> headAndTail()

Description copied from interface: Traversable

extract head and tail together, where head is expected to be present

 {
        @code
        SequenceM<String> helloWorld = ReactiveSeq.of("hello", "world", "last");
        HeadAndTail<String> headAndTail = helloWorld.headAndTail();
        String head = headAndTail.head();
        assertThat(head, equalTo("hello"));
 
        SequenceM<String> tail = headAndTail.tail();
        assertThat(tail.headAndTail().head(), equalTo("world"));
 }

Specified by:: headAndTail in interface Traversable<T>
Returns:

head
```
default T head()
```

from

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

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

reverse in interface Traversable<T>

single

default T single()

  
    
    //1
    ReactiveSeq.of(1).single(); 
    
    //UnsupportedOperationException
    ReactiveSeq.of().single();
     
     //UnsupportedOperationException
    ReactiveSeq.of(1,2,3).single();

Specified by:: single in interface Traversable<T>
Returns:: a single value or an UnsupportedOperationException if 0/1 values in this Stream

single

default T single(java.util.function.Predicate<? super T> predicate)

Specified by:: single in interface Traversable<T>

singleOptional

default java.util.Optional<T> singleOptional()

  
    
    //Optional[1]
    ReactiveSeq.of(1).singleOptional(); 
    
    //Optional.empty
    ReactiveSeq.of().singleOpional();
     
     //Optional.empty
    ReactiveSeq.of(1,2,3).singleOptional();

Specified by:: singleOptional in interface Traversable<T>
Returns:: An Optional with single value if this Stream has exactly one element, otherwise Optional Empty

findFirst

default java.util.Optional<T> findFirst()

Specified by:

findFirst in interface Traversable<T>

Returns:

First matching element in sequential order

 
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findFirst().get();
 
 //3

(deterministic)

findAny
```
default java.util.Optional<T> findAny()
```
Specified by:

findAny in interface Traversable<T>

Returns:
first matching element, but order is not guaranteed
```
 
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findAny().get();
 
 //3
 
 
```
(non-deterministic)

groupBy

default <K> MapX<K,java.util.List<T>> groupBy(java.util.function.Function<? super T,? extends K> classifier)

Description copied from interface: Traversable

Use classifier function to group elements in this Sequence into a Map

 {
        @code
        Map<Integer, List<Integer>> map1 = of(1, 2, 3, 4).groupBy(i -> i % 2);
        assertEquals(asList(2, 4), map1.get(0));
        assertEquals(asList(1, 3), map1.get(1));
        assertEquals(2, map1.size());
 
 }

Specified by:: groupBy in interface Traversable<T>

filter

CollectionX<T> filter(java.util.function.Predicate<? super T> pred)

Specified by:: filter in interface Filterable<T>

map

<R> CollectionX<R> map(java.util.function.Function<? super T,? extends R> mapper)

Specified by:: map in interface Functor<T>
Specified by:: map in interface IterableFunctor<T>

flatMap

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

limit
```
CollectionX<T> limit(long num)
```
Description copied from interface: Traversable
```
  assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
 
```
Specified by:

limit in interface Traversable<T>

Parameters:

num - Limit element size to num

Returns:

Monad converted to Stream with elements up to num

skip
```
CollectionX<T> skip(long num)
```
Description copied from interface: Traversable
```
  assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
Specified by:

skip in interface Traversable<T>

Parameters:

num - Number of elemenets to skip

Returns:

Stream with specified number of elements skipped

takeWhile

CollectionX<T> takeWhile(java.util.function.Predicate<? super T> p)

Specified by:: takeWhile in interface Traversable<T>

dropWhile

CollectionX<T> dropWhile(java.util.function.Predicate<? super T> p)

Specified by:: dropWhile in interface Traversable<T>

takeUntil

CollectionX<T> takeUntil(java.util.function.Predicate<? super T> p)

Specified by:: takeUntil in interface Traversable<T>

dropUntil

CollectionX<T> dropUntil(java.util.function.Predicate<? super T> p)

Specified by:: dropUntil in interface Traversable<T>

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

dropRight in interface Traversable<T>

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

takeRight in interface Traversable<T>

peek

default CollectionX<T> peek(java.util.function.Consumer<? super T> c)

Specified by:: peek in interface Functor<T>

grouped

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

grouped

<K,A,D> CollectionX<org.jooq.lambda.tuple.Tuple2<K,D>> grouped(java.util.function.Function<? super T,? extends K> classifier,
                                                               java.util.stream.Collector<? super T,A,D> downstream)

Specified by:: grouped in interface Traversable<T>

grouped

<K> CollectionX<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 Traversable<T>

combine
```
CollectionX<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
                       java.util.function.BinaryOperator<T> op)
```
Description copied from interface: Traversable
Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping & 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 Traversable<T>

Parameters:

predicate - Test to see if two neighbours should be joined

op - Reducer to combine neighbours

Returns:

Combined / Partially Reduced Traversable

zip

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

zip

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

Specified by:: zip in interface Traversable<T>

zipStream

<U> CollectionX<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 Traversable<T>

zipWithIndex

CollectionX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()

Description copied from interface: Traversable

Add an index to the current Stream

  
 assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").zipWithIndex().toList());

Specified by:: zipWithIndex in interface Traversable<T>

sliding

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

sliding

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

scanLeft

CollectionX<T> scanLeft(Monoid<T> monoid)

Description copied from interface: Traversable

Scan left using supplied Monoid

   
 
 	assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
 													.scanLeft(Reducers.toString("")).toList());

Specified by:: scanLeft in interface Traversable<T>
Returns:

scanLeft

<U> CollectionX<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 Traversable<T>

scanRight

CollectionX<T> scanRight(Monoid<T> monoid)

Description copied from interface: Traversable

Scan right

  
 assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
             is(asList("", "c", "bc", "abc").size()));

Specified by:: scanRight in interface Traversable<T>

scanRight

<U> CollectionX<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 Traversable<T>

distinct
```
CollectionX<T> distinct()
```
Specified by:

distinct in interface Traversable<T>

sorted

CollectionX<T> sorted()

Description copied from interface: Traversable

  assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));

Specified by:: sorted in interface Traversable<T>

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

removeAll in interface IterableFilterable<T>

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

removeAll in interface IterableFilterable<T>

removeAll

CollectionX<T> removeAll(org.jooq.lambda.Seq<T> seq)

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

removeAll in interface IterableFilterable<T>

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

retainAll in interface IterableFilterable<T>

retainAll

CollectionX<T> retainAll(org.jooq.lambda.Seq<T> seq)

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

retainAll in interface IterableFilterable<T>

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

retainAll in interface IterableFilterable<T>

filterNot

CollectionX<T> filterNot(java.util.function.Predicate<? super T> fn)

Specified by:: filterNot in interface Filterable<T>

notNull
```
CollectionX<T> notNull()
```
Specified by:

notNull in interface Filterable<T>

trampoline

<R> CollectionX<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)

Performs a map operation that can call a recursive method without running out of stack space

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

forEach3

default <R1,R2,R> ReactiveSeq<R> forEach3(java.util.function.Function<? super T,java.lang.Iterable<R1>> stream1,
                                          java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Iterable<R2>>> stream2,
                                          java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)

Perform a three level nested internal iteration over this Stream and the supplied streams

  
 ReactiveSeq.of(1,2)
 						.forEach3(a->IntStream.range(10,13),
 						        a->b->Stream.of(""+(a+b),"hello world"),
 									a->b->c->c+":"a+":"+b);
 									
 
  //SequenceM[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]

Parameters:: stream1 - Nested Stream to iterate over; stream2 - Nested Stream to iterate over; yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
Returns:: SequenceM with elements generated via nested iteration

forEach3

default <R1,R2,R> ReactiveSeq<R> forEach3(java.util.function.Function<? super T,java.lang.Iterable<R1>> stream1,
                                          java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Iterable<R2>>> stream2,
                                          java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction,
                                          java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)

Perform a three level nested internal iteration over this Stream and the supplied streams

  
 ReactiveSeq.of(1,2,3)
 						.forEach3(a->IntStream.range(10,13),
 						      a->b->Stream.of(""+(a+b),"hello world"),
 						         a->b->c-> c!=3,
 									a->b->c->c+":"a+":"+b);
 									
 
  //SequenceM[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]

Parameters:: stream1 - Nested Stream to iterate over; stream2 - Nested Stream to iterate over; filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function; yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
Returns:: SequenceM with elements generated via nested iteration

forEach2

default <R1,R> ReactiveSeq<R> forEach2(java.util.function.Function<? super T,java.lang.Iterable<R1>> stream1,
                                       java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)

Perform a two level nested internal iteration over this Stream and the supplied stream

  
 ReactiveSeq.of(1,2,3)
 						.forEach2(a->IntStream.range(10,13),
 									a->b->a+b);
 									
 
  //SequenceM[11,14,12,15,13,16]

Parameters:: stream1 - Nested Stream to iterate over; yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
Returns:: SequenceM with elements generated via nested iteration

forEach2

default <R1,R> ReactiveSeq<R> forEach2(java.util.function.Function<? super T,java.lang.Iterable<R1>> stream1,
                                       java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction,
                                       java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)

Perform a two level nested internal iteration over this Stream and the supplied stream

  
 ReactiveSeq.of(1,2,3)
 						.forEach2(a->IntStream.range(10,13),
 						            a->b-> a<3 && b>10,
 									a->b->a+b);
 									
 
  //SequenceM[14,15]

Parameters:: stream1 - Nested Stream to iterate over; filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function; yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
Returns:: SequenceM with elements generated via nested iteration

slice

CollectionX<T> slice(long from,
                     long to)

Specified by:: slice in interface Traversable<T>

sorted

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

Specified by:: sorted in interface Traversable<T>

sorted

CollectionX<T> sorted(java.util.Comparator<? super T> c)

Description copied from interface: Traversable

  
 	assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));

Specified by:: sorted in interface Traversable<T>
Parameters:: c - Compartor to sort with
Returns:: Sorted Stream

permutations
```
CollectionX<ReactiveSeq<T>> permutations()
```
Description copied from interface: ExtendedTraversable

Generate the permutations based on values in the SequenceM Makes use of Streamable to store intermediate stages in a collection

Specified by:

permutations in interface ExtendedTraversable<T>

Returns:

Permutations from this SequenceM

combinations
```
CollectionX<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 ExtendedTraversable<T>

Parameters:

size - of combinations

Returns:

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

combinations

CollectionX<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 ExtendedTraversable<T>
Returns:: All combinations of the elements in this stream

cast
```
default <U> CollectionX<U> cast(java.lang.Class<U> 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 Functor<T>

patternMatch

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

Interface CollectionX<T>

Method Summary

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.Filterable

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

fromCollection

stream

collectable

getAtIndex

headAndTail

head

from

reverse

single

single

singleOptional

findFirst

findAny

groupBy

filter

map

flatMap

limit

skip

takeWhile

dropWhile

takeUntil

dropUntil

dropRight

takeRight

peek

grouped

grouped

grouped

combine

zip

zip

zipStream

zipWithIndex

sliding

sliding

scanLeft

scanLeft

scanRight

scanRight

distinct

sorted

removeAll

removeAll

removeAll

removeAll

retainAll

retainAll

retainAll

retainAll

filterNot

notNull

trampoline

forEach3

forEach3

forEach2

forEach2

slice

sorted

sorted

permutations

combinations

combinations

cast

patternMatch