CollectionX (simple-react 1.0.0-RC4 API)

Type Parameters:

T -

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>, IterableFilterable<T>, IterableFoldable<T>, IterableFunctor<T>, org.reactivestreams.Publisher<T>, Sequential<T>, TransformerTraversable<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>, java.lang.Iterable<T>, Sequential<T>, IterableFunctor<T>, IterableFoldable<T>, IterableFilterable<T>, ZippingApplicativable<T>, Unit<T>, java.util.Collection<T>, CyclopsCollectable<T>
```
An interface that extends JDK Collection interface with a significant number of new operators

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <U> CollectionX<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a 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>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`CollectionX<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`CollectionX<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`CollectionX<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`CollectionX<T>`	`distinct()`
`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)` Keep only elements for which the supplied predicates hold e.g.
`CollectionX<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`default java.util.Optional<T>`	`findAny()`
`default java.util.Optional<T>`	`findFirst()`
`<R> CollectionX<R>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)`
`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)` Create a CollectionX from the supplied Collection
`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
`<C extends java.util.Collection<? super T>> CollectionX<C>`	`grouped(int size, java.util.function.Supplier<C> supplier)` Batch elements in a Stream by size into a collection created by the supplied factory
`CollectionX<ListX<T>>`	`groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)` Create Travesable of Lists where each List is populated while the supplied bipredicate holds.
`CollectionX<ListX<T>>`	`groupedUntil(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, where each batch is populated until the predicate holds
`<C extends java.util.Collection<? super T>> CollectionX<C>`	`groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a SequenceM batched by a Collection, where each batch is populated until the predicate holds
`CollectionX<ListX<T>>`	`groupedWhile(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, where each batch is populated while the predicate holds
`<C extends java.util.Collection<? super T>> CollectionX<C>`	`groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds
`default T`	`head()`
`default HeadAndTail<T>`	`headAndTail()` extract head and tail together, where head is expected to be present
`CollectionX<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`CollectionX<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`CollectionX<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`CollectionX<T>`	`limitUntil(java.util.function.Predicate<? super T> p)` Take elements from the Stream until the predicate returns true, after which all elements are excluded.
`CollectionX<T>`	`limitWhile(java.util.function.Predicate<? super T> p)` Take elements from the Stream while the predicate holds, once the predicate returns false all subsequent elements are excluded
`<R> CollectionX<R>`	`map(java.util.function.Function<? super T,? extends R> mapper)` Transform this functor using the supplied transformation function
`CollectionX<T>`	`notNull()` Filter elements retaining only values which are not null
`CollectionX<T>`	`onEmpty(T value)`
`CollectionX<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)`
`<X extends java.lang.Throwable> CollectionX<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)`
`default <R> CollectionX<R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<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)` Peek at the current value of this Functor, without transforming it
`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<? extends T> it)` Remove all elements in the supplied Iterable from this filterable
`CollectionX<T>`	`removeAll(org.jooq.lambda.Seq<? extends T> seq)`
`CollectionX<T>`	`removeAll(java.util.stream.Stream<? extends T> stream)` Remove all elements in the supplied Stream from this filterable
`CollectionX<T>`	`removeAll(T... values)` Remove all supplied elements from this filterable
`CollectionX<T>`	`retainAll(java.lang.Iterable<? extends T> it)` Retain only the supplied elements in the returned Filterable
`CollectionX<T>`	`retainAll(org.jooq.lambda.Seq<? extends T> seq)`
`CollectionX<T>`	`retainAll(java.util.stream.Stream<? extends T> seq)` Retain only the supplied elements in the returned Filterable
`CollectionX<T>`	`retainAll(T... values)` Retain only the supplied elements in the returned Filterable
`CollectionX<T>`	`reverse()`
`CollectionX<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> CollectionX<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`CollectionX<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> CollectionX<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`CollectionX<T>`	`shuffle()`
`CollectionX<T>`	`shuffle(java.util.Random random)`
`default 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>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`CollectionX<T>`	`skipUntil(java.util.function.Predicate<? super T> p)` Drop elements from the Stream until the predicate returns true, after which all elements are included
`CollectionX<T>`	`skipWhile(java.util.function.Predicate<? super T> p)` SkipWhile drops elements from the Stream while the predicate holds, once the predicte returns true all subsequent elements are included *
`CollectionX<T>`	`slice(long from, long to)`
`CollectionX<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<? extends U> other)`
`<U,R> CollectionX<R>`	`zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`<U> CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<? extends U> other)`
`<U,R> CollectionX<R>`	`zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`<U> CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.util.stream.Stream<? extends U> other)` Zip 2 streams into one
`<U,R> CollectionX<R>`	`zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`<S,U> CollectionX<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
`<T2,T3,T4> CollectionX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.util.stream.Stream<? extends T2> second, java.util.stream.Stream<? extends T3> third, java.util.stream.Stream<? extends T4> fourth)` zip 4 Streams into 1
`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.TransformerTraversable
groupedStatefullyWhileT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT

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

Methods inherited from interface com.aol.cyclops.types.IterableFoldable
foldable, visit

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.Foldable
endsWith, endsWithIterable, firstValue, foldRight, foldRight, foldRight, foldRightMapToType, get, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, xMatch

Methods inherited from interface com.aol.cyclops.types.Traversable
futureOperations, lazyOperations, subscribe, traversable

Methods inherited from interface com.aol.cyclops.types.stream.ConvertableSequence
seq, toCompletableFuture, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toOptional, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary

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

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, bitAnd, bitAnd, bitAndInt, bitAndLong, bitOr, bitOr, bitOrInt, bitOrLong, collect, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, max, max, max, maxAll, maxAll, maxAll, maxAll, maxAllBy, maxAllBy, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, min, minAll, minAll, minAll, minAll, minAllBy, minAllBy, minBy, minBy, mode, modeAll, modeAllBy, modeBy, noneMatch, percentile, percentile, percentileBy, percentileBy, sum, sum, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, 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)
```
Create a CollectionX from the supplied Collection

Parameters:

col -

Returns:

zip

<U> CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)

Specified by:: zip in interface Traversable<T>

grouped

<C extends java.util.Collection<? super T>> CollectionX<C> grouped(int size,
                                                                   java.util.function.Supplier<C> supplier)

Description copied from interface: Traversable

Batch elements in a Stream by size into a 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
```
CollectionX<ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
```
Description copied from interface: Traversable
Create a Traversable batched by List, where each batch is populated until the predicate holds
```
  
  assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .groupedUntil(i->i%3==0)
              .toList()
              .size(),equalTo(2));
 
 
```
Specified by:

groupedUntil in interface Traversable<T>

Parameters:

predicate - Batch until predicate holds, then open next batch

Returns:

SequenceM batched into lists determined by the predicate supplied

groupedStatefullyWhile
```
CollectionX<ListX<T>> groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
```
Description copied from interface: Traversable
Create Travesable of Lists where each List is populated while the supplied bipredicate holds. The bipredicate recieves the List from the last window as well as the current value and can choose to aggregate the current value or create a new window
```
  
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .groupedStatefullyWhile((s,i)->s.contains(4) ? true : false)
              .toList().size(),equalTo(5));
 
 
```
Specified by:

groupedStatefullyWhile in interface Traversable<T>

Parameters:

predicate - Window while true

Returns:

Traversable windowed while predicate holds

groupedWhile
```
CollectionX<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
```
Description copied from interface: Traversable
Create a Traversable batched by List, where each batch is populated while the predicate holds
```
  
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .groupedWhile(i->i%3!=0)
              .toList().size(),equalTo(2));
  
 
 
```
Specified by:

groupedWhile in interface Traversable<T>

Parameters:

predicate - Batch while predicate holds, then open next batch

Returns:

SequenceM batched into lists determined by the predicate supplied

groupedWhile
```
<C extends java.util.Collection<? super T>> CollectionX<C> groupedWhile(java.util.function.Predicate<? super T> predicate,
                                                                        java.util.function.Supplier<C> factory)
```
Description copied from interface: Traversable
Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds
```
  
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .batchWhile(i->i%3!=0)
              .toList()
              .size(),equalTo(2));
 
 
```
Specified by:

groupedWhile in interface Traversable<T>

Parameters:

predicate - Batch while predicate holds, then open next batch

factory - Collection factory

Returns:

SequenceM batched into collections determined by the predicate supplied

groupedUntil
```
<C extends java.util.Collection<? super T>> CollectionX<C> groupedUntil(java.util.function.Predicate<? super T> predicate,
                                                                        java.util.function.Supplier<C> factory)
```
Description copied from interface: Traversable
Create a 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

intersperse
```
CollectionX<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
```
CollectionX<T> shuffle()
```
Specified by:

shuffle in interface Traversable<T>

shuffle
```
CollectionX<T> shuffle(java.util.Random random)
```
Specified by:

shuffle in interface Traversable<T>

zip3

<S,U> CollectionX<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.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

<T2,T3,T4> CollectionX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<? extends T2> second,
                                                                      java.util.stream.Stream<? extends T3> third,
                                                                      java.util.stream.Stream<? extends 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>

limitWhile
```
CollectionX<T> limitWhile(java.util.function.Predicate<? super T> p)
```
Description copied from interface: Traversable
Take elements from the Stream while the predicate holds, once the predicate returns false all subsequent elements are excluded
```
  assertThat(ReactiveSeq.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
 
```
Specified by:

limitWhile in interface Traversable<T>

Parameters:

p - Limit while predicate is true

Returns:

Stream with limited elements

limitUntil
```
CollectionX<T> limitUntil(java.util.function.Predicate<? super T> p)
```
Description copied from interface: Traversable
Take elements from the Stream until the predicate returns true, after which all elements are excluded.
```
  assertThat(ReactiveSeq.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3))); 
 
```
Specified by:

limitUntil in interface Traversable<T>

Parameters:

p - Limit until predicate is true

Returns:

Stream with limited elements

limitLast
```
CollectionX<T> limitLast(int num)
```
Description copied from interface: Traversable
Limit results to the last x elements in a SequenceM
```
  
 	assertThat(ReactiveSeq.of(1,2,3,4,5)
 							.limitLast(2)
 							.collect(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

skipWhile
```
CollectionX<T> skipWhile(java.util.function.Predicate<? super T> p)
```
Description copied from interface: Traversable
SkipWhile drops elements from the Stream while the predicate holds, once the predicte returns true all subsequent elements are included *
```
 
 assertThat(ReactiveSeq.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
 
 
```
Specified by:

skipWhile in interface Traversable<T>

Parameters:

p - Predicate to skip while true

Returns:

Stream with elements skipped while predicate holds

skipUntil
```
CollectionX<T> skipUntil(java.util.function.Predicate<? super T> p)
```
Description copied from interface: Traversable
Drop elements from the Stream until the predicate returns true, after which all elements are included
```
  assertThat(ReactiveSeq.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
 
```
Specified by:

skipUntil in interface Traversable<T>

Parameters:

p - Predicate to skip until true

Returns:

Stream with elements skipped until predicate holds

skipLast
```
CollectionX<T> skipLast(int num)
```
Description copied from interface: Traversable

assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));

Specified by:

skipLast in interface Traversable<T>

Returns:

cycle
```
CollectionX<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
```
CollectionX<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

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

CollectionX<T> cycleUntil(java.util.function.Predicate<? super T> predicate)

Description copied from interface: Traversable

Repeat in a Stream until specified predicate holds

  
 	MutableInt count =MutableInt.of(0);
 		ReactiveSeq.of(1,2,2)
 		 		.cycleUntil(next -> count.get()>6)
 		 		.peek(i-> count.mutate(i->i+1))
 		 		.collect(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

onEmpty
```
CollectionX<T> onEmpty(T value)
```
Specified by:

onEmpty in interface Traversable<T>

onEmptyGet

CollectionX<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)

Specified by:: onEmptyGet in interface Traversable<T>

onEmptyThrow

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

Specified by:: onEmptyThrow in interface Traversable<T>

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 ExtendedTraversable<T>

Specified by:

stream in interface Foldable<T>

Specified by:

stream in interface IterableFunctor<T>

Specified by:

stream in interface Sequential<T>

Specified by:

stream in interface TransformerTraversable<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)

Parameters:: index -
Returns:

headAndTail

default HeadAndTail<T> headAndTail()

Description copied from interface: IterableFoldable

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 IterableFoldable<T>
Returns:

head
```
default T head()
```
Returns:

from

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

Parameters:: c -
Returns:

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

reverse in interface Traversable<T>

single

default T single()

Description copied from interface: Foldable

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

Specified by:: single in interface Foldable<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 Foldable<T>

singleOptional

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

Description copied from interface: Foldable

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

Specified by:: singleOptional in interface Foldable<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 Foldable<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 Foldable<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: Foldable

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 Foldable<T>

filter
```
CollectionX<T> filter(java.util.function.Predicate<? super T> pred)
```
Description copied from interface: Filterable
Keep only elements for which the supplied predicates hold e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[3]
   
 
 
```
Specified by:

filter in interface Filterable<T>

Parameters:

pred - to filter elements by, retaining matches

Returns:

Filterable with elements removed where the predicate does not hold

map
```
<R> CollectionX<R> map(java.util.function.Function<? super T,? extends R> mapper)
```
Description copied from interface: Functor
Transform this functor using the supplied transformation function
```
  
  
  
    of(1,2,3).map(i->i*2)
    
    //[2,4,6]
  
 
 
```
Specified by:

map in interface Functor<T>

Specified by:

map in interface IterableFunctor<T>

Parameters:

mapper - Transformation function

Returns:

Transformed Functor

flatMap

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

Parameters:: mapper -
Returns:

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)
```
Description copied from interface: Functor
Peek at the current value of this Functor, without transforming it
```
  
  
  
    of(1,2,3).map(System.out::println)
    
    1
    2
    3
  
 
 
```
Specified by:

peek in interface Functor<T>

Parameters:

c - Consumer that recieves each element from this Functor

Returns:

Functor that will peek at each value

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<? extends U> other)

Specified by:: zip in interface Traversable<T>
Parameters:: other -
Returns:

zip

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

Specified by:: zip in interface Traversable<T>

zip

<U,R> CollectionX<R> zip(org.jooq.lambda.Seq<? extends U> other,
                         java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Specified by:: zip in interface Traversable<T>

zip

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

Specified by:: zip in interface Traversable<T>

zip

<U> CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.util.stream.Stream<? extends 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>

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<? super U,? super T,? extends U> function)

Description copied from interface: Traversable

Scan left

  
  assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
         		is(4));

Specified by:: scanLeft in interface Traversable<T>

scanRight

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

Description copied from interface: Traversable

Scan right

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

Specified by:: scanRight in interface Traversable<T>

scanRight

<U> CollectionX<U> scanRight(U identity,
                             java.util.function.BiFunction<? super T,? super U,? extends U> combiner)

Description copied from interface: Traversable

Scan right

  
 assertThat(of("a", "ab", "abc").map(str->str.length()).scanRight(0, (t, u) -> u + t).toList().size(),
             is(asList(0, 3, 5, 6).size()));

Specified by:: scanRight in interface Traversable<T>

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

distinct in interface Traversable<T>

sorted

CollectionX<T> sorted()

Description copied from interface: Traversable

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

Specified by:: sorted in interface Traversable<T>

removeAll
```
CollectionX<T> removeAll(java.util.stream.Stream<? extends T> stream)
```
Description copied from interface: IterableFilterable

Remove all elements in the supplied Stream from this filterable

Specified by:

removeAll in interface IterableFilterable<T>

Parameters:

stream - of elements to remove

Returns:

Filterable with all supplied elements removed

removeAll
```
CollectionX<T> removeAll(java.lang.Iterable<? extends T> it)
```
Description copied from interface: IterableFilterable

Remove all elements in the supplied Iterable from this filterable

Specified by:

removeAll in interface IterableFilterable<T>

Parameters:

it - an Iterable of elements to remove

Returns:

Filterable with all supplied elements removed

removeAll

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

Parameters:: seq -
Returns:

removeAll
```
CollectionX<T> removeAll(T... values)
```
Description copied from interface: IterableFilterable

Remove all supplied elements from this filterable

Specified by:

removeAll in interface IterableFilterable<T>

Parameters:

values - to remove

Returns:

Filterable with all supplied values removed

retainAll
```
CollectionX<T> retainAll(java.lang.Iterable<? extends T> it)
```
Description copied from interface: IterableFilterable

Retain only the supplied elements in the returned Filterable

Specified by:

retainAll in interface IterableFilterable<T>

Parameters:

it - Iterable of elements to retain

Returns:

Filterable with supplied values retained, and others removed

retainAll

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

Parameters:: seq -
Returns:

retainAll
```
CollectionX<T> retainAll(java.util.stream.Stream<? extends T> seq)
```
Description copied from interface: IterableFilterable

Retain only the supplied elements in the returned Filterable

Specified by:

retainAll in interface IterableFilterable<T>

Parameters:

seq - of elements to retain

Returns:

Filterable with supplied values retained, and others removed

retainAll
```
CollectionX<T> retainAll(T... values)
```
Description copied from interface: IterableFilterable

Retain only the supplied elements in the returned Filterable

Specified by:

retainAll in interface IterableFilterable<T>

Parameters:

values - elements to retain

Returns:

Filterable with supplied values retained, and others removed

filterNot
```
CollectionX<T> filterNot(java.util.function.Predicate<? super T> fn)
```
Description copied from interface: Filterable
Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[1,2]
   
 
 
```
Specified by:

filterNot in interface Filterable<T>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filterable with elements removed where the predicate does not hold

notNull
```
CollectionX<T> notNull()
```
Description copied from interface: Filterable
Filter elements retaining only values which are not null
```
  
 
   of(1,2,null,4).nonNull();
 
   //[1,2,4]
   
 
```
Specified by:

notNull in interface Filterable<T>

Returns:

Filterable with nulls removed

trampoline

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

Description copied from interface: Functor

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

  
   
   //collectionX [1,2]
   
   collectionX.forEach3(a->IntStream.range(10,13),
                              a->b->Stream.of(""+(a+b),"hello world"),
                                  a->b->c->c+":"a+":"+b);
                                  
 
  //ReactiveSeq[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:: ReactiveSeq 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

  
  //collectionX [1,2,3]
  
 collectionX.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);
                                  
 
  //ReactiveSeq[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:: ReactiveSeq 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

  
  //collectionX [1,2,3]
  
 collectionX.of(1,2,3).forEach2(a->IntStream.range(10,13),
                                  a->b->a+b);
                                  
 
  //ReactiveSeq[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:: ReactiveSeq 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

  
 
 //collectionX [1,2,3]
  
 collectionX.of(1,2,3).forEach2(a->IntStream.range(10,13),
                                  a->b-> a<3 && b>10,
                                  a->b->a+b);
                                  
 
  //ReactiveSeq[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:: ReactiveSeq 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<? extends 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.CheckValue1<T,R>,Matchable.CheckValue1<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.TransformerTraversable

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

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

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

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

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

Methods inherited from interface java.lang.Iterable

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

zip

grouped

groupedUntil

groupedStatefullyWhile

groupedWhile

groupedWhile

groupedUntil

intersperse

shuffle

shuffle

zip3

zip4

limitWhile

limitUntil

limitLast

skipWhile

skipUntil

skipLast

cycle

cycle

cycleWhile

cycleUntil

onEmpty

onEmptyGet

onEmptyThrow

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

zip

zip

zip

zipWithIndex

sliding

sliding