AbstractFluentCollectionX (cyclops-reactor 8.4.2 API)

java.lang.Object
- com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX<T>

Type Parameters:

T -

All Implemented Interfaces:

CollectionX<T>, FluentCollectionX<T>, LazyFluentCollectionX<T>, ReactorConvertable<T>, ZippingApplicativable<T>, ExtendedTraversable<T>, Filterable<T>, Foldable<T>, Functor<T>, IterableFilterable<T>, IterableFoldable<T>, IterableFunctor<T>, OnEmpty<T>, Sequential<T>, ConvertableSequence<T>, CyclopsCollectable<T>, TransformerTraversable<T>, Traversable<T>, Unit<T>, Zippable<T>, java.lang.Iterable<T>, java.util.Collection<T>, org.jooq.lambda.Collectable<T>, org.reactivestreams.Publisher<T>

Direct Known Subclasses:

LazyDequeX, LazyListX, LazyPBagX, LazyPOrderedSetX, LazyPQueueX, LazyPSetX, LazyPStackX, LazyPVectorX, LazyQueueX, LazySetX, LazySortedSetX
```
public abstract class AbstractFluentCollectionX<T>
extends java.lang.Object
implements LazyFluentCollectionX<T>, ReactorConvertable<T>
```
Abstract Class representing a Fluent, Lazy, extended Collection

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`AbstractFluentCollectionX.LazyCollection<T,C extends java.util.Collection<T>>`
`static class`	`AbstractFluentCollectionX.PersistentLazyCollection<T,C extends java.util.Collection<T>>`

Constructor Summary

Constructors
Constructor and Description

AbstractFluentCollectionX()

Constructors
Constructor and Description
`AbstractFluentCollectionX()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`<U> FluentCollectionX<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`FluentCollectionX<ReactiveSeq<T>>`	`combinations()` Generate the combinations based on values in the ExtendedTraversable.
`FluentCollectionX<ReactiveSeq<T>>`	`combinations(int size)` Generate the combinations based on values in the ExtendedTraversable.
`FluentCollectionX<T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)` Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation.
`FluentCollectionX<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`FluentCollectionX<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`FluentCollectionX<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`FluentCollectionX<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`FluentCollectionX<T>`	`distinct()`
`FluentCollectionX<T>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the end of this Traversable
`FluentCollectionX<T>`	`dropUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`FluentCollectionX<T>`	`dropWhile(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
`FluentCollectionX<T>`	`filter(java.util.function.Predicate<? super T> pred)` Keep only elements for which the supplied predicates hold e.g.
`FluentCollectionX<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<R> CollectionX<R>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)` Perform a flatMap operation on this collection.
`abstract reactor.core.publisher.Flux<T>`	`flux()` Convert this type to a Reactor Flux
`abstract <T1> FluentCollectionX<T1>`	`from(java.util.Collection<T1> c)` Conctruct an Extended Collection from a standard Collection
`<K> FluentCollectionX<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier)` Group this Traversable by the provided classifying function and collected by the provided Collector
`<K,A,D> FluentCollectionX<org.jooq.lambda.tuple.Tuple2<K,D>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)` Group this Traversable by the provided classifying function and collected by the provided Collector
`FluentCollectionX<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`<C extends java.util.Collection<? super T>> FluentCollectionX<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
`FluentCollectionX<ListX<T>>`	`groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)` Create Travesable of Lists where each List is populated while the supplied bipredicate holds.
`FluentCollectionX<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>> FluentCollectionX<C>`	`groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
`FluentCollectionX<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>> FluentCollectionX<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
`FluentCollectionX<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`FluentCollectionX<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`FluentCollectionX<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`FluentCollectionX<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.
`FluentCollectionX<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
`FluentCollectionX<T>`	`minus(java.lang.Object e)` Remove the specified element from this collection
`FluentCollectionX<T>`	`minusAll(java.util.Collection<?> list)` Remove all the specified elements from this collection
`LazyFluentCollectionX<T>`	`minusAllLazy(java.util.Collection<?> list)` Lazily remove the elements in the supplied Collection from this Collection.
`LazyFluentCollectionX<T>`	`minusLazy(java.lang.Object e)` Lazily remove an element from this Collection.
`FluentCollectionX<T>`	`notNull()` Filter elements retaining only values which are not null
`<U> FluentCollectionX<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`FluentCollectionX<T>`	`onEmpty(T value)` If this Container instance is empty, create a new instance containing the provided value
`FluentCollectionX<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)` If this Container instance is empty, create a new instance containing the value returned from the provided Supplier
`<X extends java.lang.Throwable> FluentCollectionX<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is empty, throw the exception returned by the provided Supplier
`<R> FluentCollectionX<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
`FluentCollectionX<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Functor, without transforming it
`FluentCollectionX<ReactiveSeq<T>>`	`permutations()` Generate the permutations based on values in the ExtendedTraversable.
`FluentCollectionX<T>`	`plus(T e)` Add an element to this Collection
`FluentCollectionX<T>`	`plusAll(java.util.Collection<? extends T> list)` Add all supplied elements to this Collection
`LazyFluentCollectionX<T>`	`plusAllLazy(java.util.Collection<? extends T> list)` Lazily add all the elements in the supplied Collection to this Collection.
`LazyFluentCollectionX<T>`	`plusLazy(T e)` Lazily add an element to this Collection.
`FluentCollectionX<T>`	`removeAll(java.lang.Iterable<? extends T> it)` Remove all elements in the supplied Iterable from this filterable
`FluentCollectionX<T>`	`removeAll(org.jooq.lambda.Seq<? extends T> stream)` Remove all elements from this collection that match the values in the provided Seq
`FluentCollectionX<T>`	`removeAll(java.util.stream.Stream<? extends T> stream)` Remove all elements in the supplied Stream from this filterable
`FluentCollectionX<T>`	`removeAll(T... values)` Remove all supplied elements from this filterable
`FluentCollectionX<T>`	`retainAll(java.lang.Iterable<? extends T> it)` Retain only the supplied elements in the returned Filterable
`FluentCollectionX<T>`	`retainAll(org.jooq.lambda.Seq<? extends T> stream)` Retain all elements from this collection that match the values in the provided Seq
`FluentCollectionX<T>`	`retainAll(java.util.stream.Stream<? extends T> stream)` Retain only the supplied elements in the returned Filterable
`FluentCollectionX<T>`	`retainAll(T... values)` Retain only the supplied elements in the returned Filterable
`FluentCollectionX<T>`	`reverse()` Potentially efficient Stream reversal.
`FluentCollectionX<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> FluentCollectionX<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`FluentCollectionX<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> FluentCollectionX<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`FluentCollectionX<T>`	`shuffle()`
`FluentCollectionX<T>`	`shuffle(java.util.Random random)`
`FluentCollectionX<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`FluentCollectionX<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`FluentCollectionX<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
`FluentCollectionX<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 *
`FluentCollectionX<T>`	`slice(long from, long to)`
`FluentCollectionX<ListX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`FluentCollectionX<ListX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`FluentCollectionX<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`FluentCollectionX<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>> FluentCollectionX<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`abstract <X> FluentCollectionX<X>`	`stream(reactor.core.publisher.Flux<X> stream)` Create a LazyFluentCollection from a Flux.
`FluentCollectionX<T>`	`takeRight(int num)` Generate a new Traversable that takes the specified number elements from the end of this Traversable
`FluentCollectionX<T>`	`takeUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`FluentCollectionX<T>`	`takeWhile(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
`<R> FluentCollectionX<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
`abstract <U> IterableFunctor<U>`	`unitIterator(java.util.Iterator<U> U)` Create an IterableFunctor instance of the same type from an Iterator
`<T2,R> Zippable<R>`	`zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> publisher)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`<U> FluentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)` Zip (merge) this collection with the supplied Iterable into a Colleciton containing Tuples Each Tuple contains one element from this collection and one from the other
`<U,R> FluentCollectionX<R>`	`zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
`<U> FluentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<? extends U> other)` Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
`<U,R> FluentCollectionX<R>`	`zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Seq, using the supplied combining function
`<U> FluentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.util.stream.Stream<? extends U> other)` Zip 2 streams into one
`<U,R> FluentCollectionX<R>`	`zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
`<S,U> FluentCollectionX<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> FluentCollectionX<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
`FluentCollectionX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
materialize, plusInOrder, plusLoop, plusLoop, unit

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

Methods inherited from interface com.aol.cyclops.types.TransformerTraversable
groupedStatefullyUntilT, 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.applicative.zipping.ZippingApplicativable
ap1, ap2, ap3, ap4, ap5, applicatives

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

Methods inherited from interface 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 java.lang.Iterable
forEach, iterator, spliterator

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.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, foldFuture, foldLazy, foldTry, 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

Methods inherited from interface com.aol.cyclops.reactor.types.ReactorConvertable
mono

- Constructor Detail
 - AbstractFluentCollectionX
```
public AbstractFluentCollectionX()
```
- Method Detail
 - flux
```
public abstract reactor.core.publisher.Flux<T> flux()
```
 Description copied from interface: ReactorConvertable
 
 Convert this type to a Reactor Flux
 
 Specified by:
 
 flux in interface ReactorConvertable<T>
 
 Returns:
 
 Reactor Flux
 - stream
```
public abstract <X> FluentCollectionX<X> stream(reactor.core.publisher.Flux<X> stream)
```
 Description copied from interface: LazyFluentCollectionX
 Create a LazyFluentCollection from a Flux. The created LazyFluentCollection will be of the same type as the object this method is called on. i.e. Calling stream(Flux) on a LazyListX results in a LazyListX
```
 
 
 LazyListX<Integer> lazyInts = LazyListX.of(1,2,3);
 LazyListX<String> lazyStrs = lazyInts.stream(Flux.just("hello","world"));
 
 
 
```
 Calling stream(Flux) on a LazySetX results in a LazySetX etc. The same collection / reduction method will be used in the newly created Object. I.e. Calling stream(Flux) on a collection which as an Immutable Collector will result in an Immutable Collection.
 Specified by:
 
 stream in interface LazyFluentCollectionX<T>
 
 Parameters:
 
 stream - Flux to create new collection from
 
 Returns:
 
 New collection from Flux
 - plusLazy
```
public LazyFluentCollectionX<T> plusLazy(T e)
```
 Description copied from interface: LazyFluentCollectionX
 Lazily add an element to this Collection. The Collection will not be materialized (unlike via @see LazyFluentCollectionX.plus(Object)
```
 
 LazyListX<Integer> lazy = LazyListX.of(1,2,3)
 .map(i->i*2)
 .plusLazy(5);
 
 //Lazy List that will contain [2,4,6,5] when triggered 
 
 
```
 Specified by:
 
 plusLazy in interface LazyFluentCollectionX<T>
 
 Parameters:
 
 e - Element to add
 
 Returns:
 
 LazyFluentCollectionX with element added
 - plus
```
public FluentCollectionX<T> plus(T e)
```
 Description copied from interface: FluentCollectionX
 
 Add an element to this Collection
 
 Specified by:
 
 plus in interface FluentCollectionX<T>
 
 Specified by:
 
 plus in interface LazyFluentCollectionX<T>
 
 Parameters:
 
 e - Element to add
 
 Returns:
 
 Collection with element added
 - plusAll
```
public FluentCollectionX<T> plusAll(java.util.Collection<? extends T> list)
```
 Description copied from interface: FluentCollectionX
 
 Add all supplied elements to this Collection
 
 Specified by:
 
 plusAll in interface FluentCollectionX<T>
 
 Specified by:
 
 plusAll in interface LazyFluentCollectionX<T>
 
 Parameters:
 
 list - of elements to add
 
 Returns:
 
 Collection with elements added
 - minus
```
public FluentCollectionX<T> minus(java.lang.Object e)
```
 Description copied from interface: FluentCollectionX
 
 Remove the specified element from this collection
 
 Specified by:
 
 minus in interface FluentCollectionX<T>
 
 Specified by:
 
 minus in interface LazyFluentCollectionX<T>
 
 Parameters:
 
 e - Element to remove
 
 Returns:
 
 Collection with element removed
 - minusAll
```
public FluentCollectionX<T> minusAll(java.util.Collection<?> list)
```
 Description copied from interface: FluentCollectionX
 
 Remove all the specified elements from this collection
 
 Specified by:
 
 minusAll in interface FluentCollectionX<T>
 
 Specified by:
 
 minusAll in interface LazyFluentCollectionX<T>
 
 Parameters:
 
 list - of elements to remove
 
 Returns:
 
 Collection with the elements removed
 - plusAllLazy
```
public LazyFluentCollectionX<T> plusAllLazy(java.util.Collection<? extends T> list)
```
 Description copied from interface: LazyFluentCollectionX
 Lazily add all the elements in the supplied Collection to this Collection. The Collection will not be materialized (unlike via @see LazyFluentCollectionX#plusAll(Object)
```
 
 LazyListX<Integer> lazy = LazyListX.of(1,2,3)
 .map(i->i*2)
 .plusAllLazy(ListX.of(5,10));
 
 //Lazy List that will contain [2,4,6,5,10] when triggered 
 
 
```
 Specified by:
 
 plusAllLazy in interface LazyFluentCollectionX<T>
 
 Parameters:
 
 list - Collection to add
 
 Returns:
 
 LazyFluentCollectionX with Collection added
 - minusLazy
```
public LazyFluentCollectionX<T> minusLazy(java.lang.Object e)
```
 Description copied from interface: LazyFluentCollectionX
 Lazily remove an element from this Collection. The Collection will not be materialized (unlike via @see LazyFluentCollectionX.minus(Object)
```
 
 LazyListX<Integer> lazy = LazyListX.of(1,2,3)
 .map(i->i*2)
 .minusLazy(4);
 
 //Lazy List that will contain [2,6] when triggered 
 
 
```
 This is an equivalent operation to filtering by equality e.g.
```
 
 LazyListX<Integer> lazy = LazyListX.of(1,2,3)
 .map(i->i*2)
 .filter(i->i==4);
 
 //Lazy List that will contain [2,6] when triggered 
 
 
```
 Specified by:
 
 minusLazy in interface LazyFluentCollectionX<T>
 
 Parameters:
 
 e - Element to remove
 
 Returns:
 
 LazyFluentCollectionX with element removed
 - minusAllLazy
```
public LazyFluentCollectionX<T> minusAllLazy(java.util.Collection<?> list)
```
 Description copied from interface: LazyFluentCollectionX
 Lazily remove the elements in the supplied Collection from this Collection. The Collection will not be materialized (unlike via @see LazyFluentCollectionX.minusAll(Collection)
```
 
 LazyListX<Integer> lazy = LazyListX.of(1,2,3)
 .map(i->i*2)
 .minusAllLazy(ListX.of(4));
 
 //Lazy List that will contain [2,6] when triggered 
 
 
```
 This is an equivalent operation to filtering by equality e.g.
```
 
 LazyListX<Integer> lazy = LazyListX.of(1,2,3)
 .map(i->i*2)
 .filter(i->ListX.of(4).contains(i));
 
 //Lazy List that will contain [2,6] when triggered 
 
 
```
 Specified by:
 
 minusAllLazy in interface LazyFluentCollectionX<T>
 
 Parameters:
 
 list - of elements to remove
 
 Returns:
 
 LazyFluentCollectionX with elements removed
 - combine
```
public FluentCollectionX<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
 java.util.function.BinaryOperator<T> op)
```
 Description copied from interface: Traversable
 Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation. The 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
 - reverse
```
public FluentCollectionX<T> reverse()
```
 Description copied from interface: Traversable
 Potentially efficient Stream reversal. Is efficient if - Sequence created via a range - Sequence created via a List - Sequence created via an Array / var args Otherwise Sequence collected into a Collection prior to reversal
```
 assertThat( of(1, 2, 3).reverse().toList(),
 equalTo(asList(3, 2, 1))); 
```
 Specified by:
 
 reverse in interface CollectionX<T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 - filter
```
public FluentCollectionX<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 CollectionX<T>
 
 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
```
public <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 CollectionX<T>
 
 Specified by:
 
 map in interface Functor<T>
 
 Specified by:
 
 map in interface IterableFunctor<T>
 
 Parameters:
 
 mapper - Transformation function
 
 Returns:
 
 Transformed Functor
 - flatMap
```
public <R> CollectionX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
```
 Description copied from interface: CollectionX
 
 Perform a flatMap operation on this collection. Results from the returned Iterables (from the provided transformation function) are flattened into the resulting collection.
 
 Specified by:
 
 flatMap in interface CollectionX<T>
 
 Parameters:
 
 mapper - Transformation function to be applied (and flattened)
 
 Returns:
 
 A collection containing the flattened results of the transformation function
 - limit
```
public FluentCollectionX<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
```
public FluentCollectionX<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
 - takeRight
```
public FluentCollectionX<T> takeRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes the specified number elements from the end of this Traversable
```
 
 ListX.of(1,2,3).takeRight(2);
 //[2,3]
 
 
```
 Specified by:
 
 takeRight in interface CollectionX<T>
 
 Specified by:
 
 takeRight in interface Traversable<T>
 
 Parameters:
 
 num - Take this number of elements from the end of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropRight
```
public FluentCollectionX<T> dropRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops the specified number elements from the end of this Traversable
```
 
 ListX.of(1,2,3).dropRight(2);
 //[1]
 
 
```
 Specified by:
 
 dropRight in interface CollectionX<T>
 
 Specified by:
 
 dropRight in interface Traversable<T>
 
 Parameters:
 
 num - Drop this number of elements from the end of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - takeWhile
```
public FluentCollectionX<T> takeWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
```
 
 ListX.of(1,2,3).takeWhile(i<3);
 //[1,2]
 
 
```
 Specified by:
 
 takeWhile in interface CollectionX<T>
 
 Specified by:
 
 takeWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be taken
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropWhile
```
public FluentCollectionX<T> dropWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
```
 
 ListX.of(1,2,3).dropWhile(i<3);
 //[3]
 
 
```
 Specified by:
 
 dropWhile in interface CollectionX<T>
 
 Specified by:
 
 dropWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - takeUntil
```
public FluentCollectionX<T> takeUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes elements from this Traversable until the predicate holds
```
 
 ListX.of(1,2,3).takeUntil(i<2);
 //[1,2]
 
 
```
 Specified by:
 
 takeUntil in interface CollectionX<T>
 
 Specified by:
 
 takeUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be taken until
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropUntil
```
public FluentCollectionX<T> dropUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops elements from this Traversable until the predicate holds
```
 
 ListX.of(1,2,3).dropUntil(i>2);
 //[3]
 
 
```
 Specified by:
 
 dropUntil in interface CollectionX<T>
 
 Specified by:
 
 dropUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - trampoline
```
public <R> FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 trampoline in interface Functor<T>
 
 Parameters:
 
 mapper - TCO Transformation function
 
 Returns:
 
 Functor transformed by the supplied transformation function
 - slice
```
public FluentCollectionX<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface CollectionX<T>
 
 Specified by:
 
 slice in interface Traversable<T>
 - grouped
```
public FluentCollectionX<ListX<T>> grouped(int groupSize)
```
 Description copied from interface: Traversable
 Group elements in a Stream
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(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
```
public <K,A,D> FluentCollectionX<org.jooq.lambda.tuple.Tuple2<K,D>> grouped(java.util.function.Function<? super T,? extends K> classifier,
 java.util.stream.Collector<? super T,A,D> downstream)
```
 Description copied from interface: Traversable
 
 Group this Traversable by the provided classifying function and collected by the provided Collector
 
 Specified by:
 
 grouped in interface CollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 classifier - Grouping function
 
 downstream - Collector to create the grouping collection
 
 Returns:
 
 Traversable of grouped data
 - grouped
```
public <K> FluentCollectionX<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
```
 Description copied from interface: Traversable
 
 Group this Traversable by the provided classifying function and collected by the provided Collector
 
 Specified by:
 
 grouped in interface CollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 classifier - Grouping function
 
 Returns:
 
 Traversable of grouped data
 - zip
```
public  FluentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
```
 Description copied from interface: CollectionX
 
 Zip (merge) this collection with the supplied Iterable into a Colleciton containing Tuples Each Tuple contains one element from this collection and one from the other
 
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Collection to merge with this one
 
 Returns:
 
 Merged collection
 - zip
```
public <U,R> FluentCollectionX<R> zip(java.lang.Iterable<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
 
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - to zip with
 
 zipper - Zip function
 
 Returns:
 
 Combined zippable
 - sliding
```
public FluentCollectionX<ListX<T>> sliding(int windowSize)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(2).collect(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
```
public FluentCollectionX<ListX<T>> sliding(int windowSize,
 int increment)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(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
```
public FluentCollectionX<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:
 - scanLeft
```
public  FluentCollectionX 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 CollectionX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 - scanRight
```
public FluentCollectionX<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>
 - scanRight
```
public  FluentCollectionX 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 CollectionX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - sorted
```
public > FluentCollectionX<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>
 - cycle
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 times - Times values should be repeated within a Stream
 
 Returns:
 
 Stream with values repeated
 - cycle
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 m - Monoid to be used in reduction
 
 times - Number of times value should be repeated
 
 Returns:
 
 Stream with reduced values repeated
 - cycleWhile
```
public FluentCollectionX<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Repeat in a Stream while specified predicate holds
```
 
 MutableInt count = MutableInt.of(0);
 ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6).collect(Collectors.toList());
 
 // List(1,2,2,1,2,2)
 
 
```
 Specified by:
 
 cycleWhile in interface CollectionX<T>
 
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - cycleUntil
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 cycleUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - zip
```
public  FluentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
 
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Seq to combine with
 
 Returns:
 
 Combined Zippable
 - zip3
```
public <S,U> FluentCollectionX<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
```
 
 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 CollectionX<T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 - zip4
```
public <T2,T3,T4> FluentCollectionX<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
```
 
 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 CollectionX<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 - zipWithIndex
```
public FluentCollectionX<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
```
public FluentCollectionX<T> distinct()
```
 Specified by:
 
 distinct in interface CollectionX<T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 - sorted
```
public FluentCollectionX<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
```
public FluentCollectionX<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
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 skipWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to skip while true
 
 Returns:
 
 Stream with elements skipped while predicate holds
 - skipUntil
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 skipUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to skip until true
 
 Returns:
 
 Stream with elements skipped until predicate holds
 - limitWhile
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 limitWhile in interface Traversable<T>
 
 Parameters:
 
 p - Limit while predicate is true
 
 Returns:
 
 Stream with limited elements
 - limitUntil
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 limitUntil in interface Traversable<T>
 
 Parameters:
 
 p - Limit until predicate is true
 
 Returns:
 
 Stream with limited elements
 - intersperse
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 intersperse in interface Traversable<T>
 - shuffle
```
public FluentCollectionX<T> shuffle()
```
 Specified by:
 
 shuffle in interface CollectionX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - skipLast
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 skipLast in interface Traversable<T>
 
 Returns:
 - limitLast
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 limitLast in interface Traversable<T>
 
 Parameters:
 
 num - of elements to return (last elements)
 
 Returns:
 
 SequenceM limited to last num elements
 - onEmpty
```
public FluentCollectionX<T> onEmpty(T value)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is empty, create a new instance containing the provided value
 
 Specified by:
 
 onEmpty in interface CollectionX<T>
 
 Specified by:
 
 onEmpty in interface OnEmpty<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 
 Returns:
 
 New instance containing value if container is empty, otherwise returns this container
 - onEmptyGet
```
public FluentCollectionX<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is empty, create a new instance containing the value returned from the provided Supplier
 
 Specified by:
 
 onEmptyGet in interface CollectionX<T>
 
 Specified by:
 
 onEmptyGet in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 
 Parameters:
 
 supplier - to determine new value for container
 
 Returns:
 
 New Container with value if this is empty, otherwise this container
 - onEmptyThrow
```
public <X extends java.lang.Throwable> FluentCollectionX<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
 Description copied from interface: OnEmpty
 
 If this container instance is empty, throw the exception returned by the provided Supplier
 
 Specified by:
 
 onEmptyThrow in interface CollectionX<T>
 
 Specified by:
 
 onEmptyThrow in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyThrow in interface Traversable<T>
 
 Parameters:
 
 supplier - to create exception from
 
 Returns:
 
 Throw exception if empty, otherwise this container
 - shuffle
```
public FluentCollectionX<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface CollectionX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - ofType
```
public  FluentCollectionX ofType(java.lang.Class<? extends U> 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
```
public FluentCollectionX<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 CollectionX<T>
 
 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
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 notNull in interface Filterable<T>
 
 Returns:
 
 Filterable with nulls removed
 - removeAll
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Parameters:
 
 stream - of elements to remove
 
 Returns:
 
 Filterable with all supplied elements removed
 - removeAll
```
public FluentCollectionX<T> removeAll(org.jooq.lambda.Seq<? extends T> stream)
```
 Description copied from interface: CollectionX
 
 Remove all elements from this collection that match the values in the provided Seq
 
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Parameters:
 
 stream - Stream of values to remove
 
 Returns:
 
 Collection with the values removed
 - removeAll
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Parameters:
 
 it - an Iterable of elements to remove
 
 Returns:
 
 Filterable with all supplied elements removed
 - removeAll
```
public FluentCollectionX<T> removeAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Remove all supplied elements from this filterable
 
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Parameters:
 
 values - to remove
 
 Returns:
 
 Filterable with all supplied values removed
 - retainAll
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Parameters:
 
 it - Iterable of elements to retain
 
 Returns:
 
 Filterable with supplied values retained, and others removed
 - retainAll
```
public FluentCollectionX<T> retainAll(java.util.stream.Stream<? extends T> stream)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filterable
 
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Parameters:
 
 stream - of elements to retain
 
 Returns:
 
 Filterable with supplied values retained, and others removed
 - retainAll
```
public FluentCollectionX<T> retainAll(org.jooq.lambda.Seq<? extends T> stream)
```
 Description copied from interface: CollectionX
 
 Retain all elements from this collection that match the values in the provided Seq
 
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Parameters:
 
 stream - Stream of values to retain
 
 Returns:
 
 Collection with the values retained
 - retainAll
```
public FluentCollectionX<T> retainAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filterable
 
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Parameters:
 
 values - elements to retain
 
 Returns:
 
 Filterable with supplied values retained, and others removed
 - cast
```
public  FluentCollectionX 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 CollectionX<T>
 
 Specified by:
 
 cast in interface Functor<T>
 - patternMatch
```
public <R> FluentCollectionX<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 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
```
public FluentCollectionX<ReactiveSeq<T>> permutations()
```
 Description copied from interface: ExtendedTraversable
 
 Generate the permutations based on values in the ExtendedTraversable.
 
 Specified by:
 
 permutations in interface CollectionX<T>
 
 Specified by:
 
 permutations in interface ExtendedTraversable<T>
 
 Returns:
 
 Permutations from this ExtendedTraversable
 - combinations
```
public FluentCollectionX<ReactiveSeq<T>> combinations(int size)
```
 Description copied from interface: ExtendedTraversable
 Generate the combinations based on values in the ExtendedTraversable.
```
 
 ExtendedTraversable<Integer> stream = ReactiveSeq.of(1,2,3);
 stream.combinations(2)
 
 //ReactiveSeq[ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[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 ExtendedTraversable of the specified size
 - combinations
```
public FluentCollectionX<ReactiveSeq<T>> combinations()
```
 Description copied from interface: ExtendedTraversable
 Generate the combinations based on values in the ExtendedTraversable.
```
 
 ReactiveSeq.of(1,2,3).combinations()
 
 //ReactiveSeq[ReactiveSeq[],ReactiveSeq[1],ReactiveSeq[2],ReactiveSeq[3].ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]
 			,ReactiveSeq[1,2,3]]
 
 
```
 Specified by:
 
 combinations in interface CollectionX<T>
 
 Specified by:
 
 combinations in interface ExtendedTraversable<T>
 
 Returns:
 
 All combinations of the elements in this ExtendedTraversable
 - grouped
```
public <C extends java.util.Collection<? super T>> FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 SequenceM batched into collection types by size
 - groupedUntil
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedWhile
```
public FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedWhile
```
public <C extends java.util.Collection<? super T>> FluentCollectionX<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 CollectionX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - groupedUntil
```
public <C extends java.util.Collection<? super T>> FluentCollectionX<C> groupedUntil(java.util.function.Predicate<? super T> predicate,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: Traversable
 Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .groupedUntil(i->i%3!=0)
 .toList()
 
 //2
 
 
```
 Specified by:
 
 groupedUntil in interface CollectionX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - groupedStatefullyUntil
```
public FluentCollectionX<ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
```
 Description copied from interface: Traversable
 Create Travesable of Lists where each List is populated while the supplied bipredicate holds. The bipredicate recieves the List from the last window as well as the current value and can choose to aggregate the current value or create a new window
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedStatefullyUntil((s,i)->s.contains(4) ? true : false)
 .toList().size(),equalTo(5));
 
 
```
 Specified by:
 
 groupedStatefullyUntil in interface CollectionX<T>
 
 Specified by:
 
 groupedStatefullyUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 Traversable windowed while predicate holds
 - from
```
public abstract <T1> FluentCollectionX<T1> from(java.util.Collection<T1> c)
```
 Description copied from interface: CollectionX
 
 Conctruct an Extended Collection from a standard Collection
 
 Specified by:
 
 from in interface CollectionX<T>
 
 Parameters:
 
 c - Collection to extend
 
 Returns:
 
 Extended Collection
 - peek
```
public FluentCollectionX<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 CollectionX<T>
 
 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
 - zip
```
public <U,R> FluentCollectionX<R> zip(org.jooq.lambda.Seq<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Seq, using the supplied combining function
 
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Seq to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zip
```
public <U,R> FluentCollectionX<R> zip(java.util.stream.Stream<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
 
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zip
```
public  FluentCollectionX<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
```
 

 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
 // [[1,"a"],[2,"b"]]
 
 
```
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - unitIterator
```
public abstract  IterableFunctor unitIterator(java.util.Iterator U)
```
 Description copied from interface: IterableFunctor
 Create an IterableFunctor instance of the same type from an Iterator
```
 
 ReactiveSeq<Integer> newSeq = seq.unitIterator(myIterator);
 
 
 
```
 Specified by:
 
 unitIterator in interface IterableFunctor<T>
 
 Parameters:
 
 U - Iterator to create new IterableFunctor from
 
 Returns:
 
 New IterableFunctor instance
 - zip
```
public <T2,R> Zippable<R> zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn,
 org.reactivestreams.Publisher<? extends T2> publisher)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 fn - Zip / combining function
 
 publisher - to combine with
 
 Returns:
 
 Combined zippable

Class AbstractFluentCollectionX<T>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX

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

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

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

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

Methods inherited from interface com.aol.cyclops.reactor.types.ReactorConvertable

Constructor Detail

AbstractFluentCollectionX

Method Detail

flux

stream

plusLazy

plus

plusAll

minus

minusAll

plusAllLazy

minusLazy

minusAllLazy

combine

reverse

filter

map

flatMap

limit

skip

takeRight

dropRight

takeWhile

dropWhile

takeUntil

dropUntil

trampoline

slice

grouped

grouped

grouped

zip

zip

sliding

sliding

scanLeft

scanLeft

scanRight

scanRight

sorted

cycle

cycle

cycleWhile

cycleUntil

zip

zip3

zip4

zipWithIndex

distinct

sorted

sorted

skipWhile

skipUntil

limitWhile

limitUntil

intersperse

shuffle

skipLast

limitLast

onEmpty