LazyPStackX (cyclops-reactor 8.4.2 API)

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

Type Parameters:

T - the type of elements held in this collection

All Implemented Interfaces:

CollectionX<T>, FluentCollectionX<T>, FluentSequenceX<T>, PersistentCollectionX<T>, PStackX<T>, LazyFluentCollectionX<T>, ReactorConvertable<T>, ZippingApplicativable<T>, ExtendedTraversable<T>, Filterable<T>, Foldable<T>, Functor<T>, IterableFilterable<T>, IterableFoldable<T>, IterableFunctor<T>, OnEmpty<T>, OnEmptySwitch<T,org.pcollections.PStack<T>>, Sequential<T>, ConvertableSequence<T>, CyclopsCollectable<T>, To<PStackX<T>>, TransformerTraversable<T>, Traversable<T>, Unit<T>, Zippable<T>, java.lang.Iterable<T>, java.util.Collection<T>, java.util.List<T>, org.jooq.lambda.Collectable<T>, org.pcollections.PCollection<T>, org.pcollections.PSequence<T>, org.pcollections.PStack<T>, org.reactivestreams.Publisher<T>
```
public class LazyPStackX<T>
extends AbstractFluentCollectionX<T>
implements PStackX<T>
```
An extended Persistent List type List This makes use of PStack (@see org.pcollections.PStack) from PCollectons. PStack is a persistent analogue of the imperative LinkedList type. Extended List operations execute lazily (compared with @see com.aol.cyclops.data.collections.extensions.persistent.PStackX) e.g.
```
 
 LazyPStackX<Integer> q = LazyPStackX.of(1,2,3)
 .map(i->i*2);
 
 
```
The map operation above is not executed immediately. It will only be executed when (if) the data inside the PStack is accessed. This allows lazy operations to be chained and executed more efficiently e.g.
```
 
 LazyPStackX<Integer> q = LazyPStackX.of(1,2,3)
 .map(i->i*2);
 .filter(i->i<5);
 
 
```
The operation above is more efficient than the equivalent operation with a PStackX.

Nested Class Summary
- Nested classes/interfaces inherited from class com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX
 AbstractFluentCollectionX.LazyCollection<T,C extends java.util.Collection<T>>, AbstractFluentCollectionX.PersistentLazyCollection<T,C extends java.util.Collection<T>>

Constructor Summary

Constructors
Constructor and Description

LazyPStackX(reactor.core.publisher.Flux<T> stream, Reducer<org.pcollections.PStack<T>> collector)

Constructors
Constructor and Description
`LazyPStackX(reactor.core.publisher.Flux<T> stream, Reducer<org.pcollections.PStack<T>> collector)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(int index, T element)`
`boolean`	`add(T e)`
`boolean`	`addAll(java.util.Collection<? extends T> c)`
`boolean`	`addAll(int index, java.util.Collection<? extends T> c)`
`<U> LazyPStackX<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`void`	`clear()`
`<R,A> R`	`collect(java.util.stream.Collector<? super T,A,R> collector)`
`LazyPStackX<ReactiveSeq<T>>`	`combinations()` Generate the combinations based on values in the ExtendedTraversable.
`LazyPStackX<ReactiveSeq<T>>`	`combinations(int size)` Generate the combinations based on values in the ExtendedTraversable.
`LazyPStackX<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.
`boolean`	`contains(java.lang.Object e)`
`boolean`	`containsAll(java.util.Collection<?> c)`
`long`	`count()`
`LazyPStackX<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`LazyPStackX<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`LazyPStackX<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`LazyPStackX<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`LazyPStackX<T>`	`distinct()`
`LazyPStackX<T>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the end of this Traversable
`LazyPStackX<T>`	`dropUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`LazyPStackX<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
`LazyPStackX<T>`	`efficientOpsOff()`
`LazyPStackX<T>`	`efficientOpsOn()`
`static <T> LazyPStackX<T>`	`empty()` `List<String> empty = PStack.empty(); //or PStack<String> empty = PStack.empty();`
`<R> LazyPStackX<R>`	`emptyUnit()`
`boolean`	`equals(java.lang.Object o)`
`LazyPStackX<T>`	`filter(java.util.function.Predicate<? super T> pred)` Keep only elements for which the supplied predicates hold e.g.
`LazyPStackX<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<R> LazyPStackX<R>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)` Perform a flatMap operation on this collection.
`reactor.core.publisher.Flux<T>`	`flux()` Convert this type to a Reactor Flux
`void`	`forEach(java.util.function.Consumer<? super T> action)`
`<X> LazyPStackX<X>`	`from(java.util.Collection<X> col)` Conctruct an Extended Collection from a standard Collection
`static <T> LazyPStackX<T>`	`fromIterable(java.lang.Iterable<T> it)` Construct LazyPStackX from an Iterable
`static <T> LazyPStackX<T>`	`fromIterable(Reducer<org.pcollections.PStack<T>> collector, java.lang.Iterable<T> it)` Construct a LazyPStackX from an Iterable, using the specified Collector.
`static <T> LazyPStackX<T>`	`fromPStack(org.pcollections.PStack<T> list, Reducer<org.pcollections.PStack<T>> collector)`
`static <T> LazyPStackX<T>`	`fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)` Construct a LazyPStackX from an Publisher
`static <T> LazyPStackX<T>`	`fromStreamS(java.util.stream.Stream<T> stream)` Create a LazyPStackX from a Stream
`static <T> LazyPStackX<T>`	`generate(long limit, java.util.function.Supplier<T> s)` Generate a LazyPStackX from the provided Supplier up to the provided limit number of times
`T`	`get(int index)`
`<K> LazyPStackX<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> LazyPStackX<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
`LazyPStackX<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`<C extends java.util.Collection<? super T>> LazyPStackX<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
`LazyPStackX<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.
`LazyPStackX<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>> LazyPStackX<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
`LazyPStackX<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>> LazyPStackX<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
`int`	`hashCode()`
`int`	`indexOf(java.lang.Object o)`
`LazyPStackX<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`boolean`	`isEmpty()`
`static <T> LazyPStackX<T>`	`iterate(long limit, T seed, java.util.function.UnaryOperator<T> f)` Create a LazyPStackX by iterative application of a function to an initial element up to the supplied limit number of times
`java.util.Iterator<T>`	`iterator()`
`int`	`lastIndexOf(java.lang.Object o)`
`static <T> java.util.stream.Collector<T,?,LazyPStackX<T>>`	`lazyListXCollector()`
`LazyPStackX<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`LazyPStackX<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`LazyPStackX<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.
`LazyPStackX<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
`java.util.ListIterator<T>`	`listIterator()`
`java.util.ListIterator<T>`	`listIterator(int index)`
`<R> LazyPStackX<R>`	`map(java.util.function.Function<? super T,? extends R> mapper)` Transform this functor using the supplied transformation function
`LazyPStackX<T>`	`materialize()`
`LazyPStackX<T>`	`minus(int i)` Remove the element at the supplied index
`LazyPStackX<T>`	`minus(java.lang.Object e)` Remove the specified element from this collection
`LazyPStackX<T>`	`minusAll(java.util.Collection<?> list)` Remove all the specified elements from this collection
`LazyPStackX<T>`	`minusAllLazy(java.util.Collection<?> list)` Lazily remove the elements in the supplied Collection from this Collection.
`LazyPStackX<T>`	`minusLazy(java.lang.Object e)` Lazily remove an element from this Collection.
`<T> Reducer<org.pcollections.PStack<T>>`	`monoid()`
`LazyPStackX<T>`	`notNull()` Filter elements retaining only values which are not null
`static <T> LazyPStackX<T>`	`of(T... values)` Create a LazyPStackX from the specified values
`<U> LazyPStackX<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`LazyPStackX<T>`	`onEmpty(T value)` If this Container instance is empty, create a new instance containing the provided value
`LazyPStackX<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
`LazyPStackX<T>`	`onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PStack<T>> supplier)` Switch to container created by provided Supplier, if current Container empty
`<X extends java.lang.Throwable> LazyPStackX<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is empty, throw the exception returned by the provided Supplier
`java.util.stream.Stream<T>`	`parallelStream()`
`<R> LazyPStackX<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
`LazyPStackX<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Functor, without transforming it
`LazyPStackX<ReactiveSeq<T>>`	`permutations()` Generate the permutations based on values in the ExtendedTraversable.
`LazyPStackX<T>`	`plus(int i, T e)` Add the supplied element at the supplied index
`LazyPStackX<T>`	`plus(T e)` Add an element to this Collection
`LazyPStackX<T>`	`plusAll(java.util.Collection<? extends T> list)` Add all supplied elements to this Collection
`LazyPStackX<T>`	`plusAll(int i, java.util.Collection<? extends T> list)` Add all of the supplied elements at the supplied index
`LazyPStackX<T>`	`plusAllLazy(java.util.Collection<? extends T> list)` Lazily add all the elements in the supplied Collection to this Collection.
`LazyPStackX<T>`	`plusInOrder(T e)` Add an element to the collection
`LazyPStackX<T>`	`plusLazy(T e)` Lazily add an element to this Collection.
`LazyPStackX<T>`	`plusLoop(int max, java.util.function.IntFunction<T> value)`
`LazyPStackX<T>`	`plusLoop(java.util.function.Supplier<java.util.Optional<T>> supplier)`
`static LazyPStackX<java.lang.Integer>`	`range(int start, int end)` Create a LazyPStackX that contains the Integers between start and end
`static LazyPStackX<java.lang.Long>`	`rangeLong(long start, long end)` Create a LazyPStackX that contains the Longs between start and end
`T`	`remove(int index)`
`boolean`	`remove(java.lang.Object o)`
`boolean`	`removeAll(java.util.Collection<?> c)`
`LazyPStackX<T>`	`removeAll(java.lang.Iterable<? extends T> it)` Remove all elements in the supplied Iterable from this filterable
`LazyPStackX<T>`	`removeAll(org.jooq.lambda.Seq<? extends T> stream)` Remove all elements from this collection that match the values in the provided Seq
`LazyPStackX<T>`	`removeAll(java.util.stream.Stream<? extends T> stream)` Remove all elements in the supplied Stream from this filterable
`LazyPStackX<T>`	`removeAll(T... values)` Remove all supplied elements from this filterable
`boolean`	`removeIf(java.util.function.Predicate<? super T> filter)`
`void`	`replaceAll(java.util.function.UnaryOperator<T> operator)`
`boolean`	`retainAll(java.util.Collection<?> c)`
`LazyPStackX<T>`	`retainAll(java.lang.Iterable<? extends T> it)` Retain only the supplied elements in the returned Filterable
`LazyPStackX<T>`	`retainAll(org.jooq.lambda.Seq<? extends T> stream)` Retain all elements from this collection that match the values in the provided Seq
`LazyPStackX<T>`	`retainAll(java.util.stream.Stream<? extends T> stream)` Retain only the supplied elements in the returned Filterable
`LazyPStackX<T>`	`retainAll(T... values)` Retain only the supplied elements in the returned Filterable
`LazyPStackX<T>`	`reverse()` Potentially efficient Stream reversal.
`LazyPStackX<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> LazyPStackX<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`LazyPStackX<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> LazyPStackX<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`T`	`set(int index, T element)`
`LazyPStackX<T>`	`shuffle()`
`LazyPStackX<T>`	`shuffle(java.util.Random random)`
`static <T> LazyPStackX<T>`	`singleton(T value)` Construct a LazyPStackX with a single value
`int`	`size()`
`LazyPStackX<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`LazyPStackX<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`LazyPStackX<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
`LazyPStackX<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 *
`LazyPStackX<T>`	`slice(long from, long to)`
`LazyPStackX<ListX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`LazyPStackX<ListX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`void`	`sort(java.util.Comparator<? super T> c)`
`LazyPStackX<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`LazyPStackX<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>> LazyPStackX<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`java.util.Spliterator<T>`	`spliterator()`
`ReactiveSeq<T>`	`stream()`
`<X> LazyPStackX<X>`	`stream(reactor.core.publisher.Flux<X> stream)` Create a LazyFluentCollection from a Flux.
`LazyPStackX<T>`	`subList(int start)`
`LazyPStackX<T>`	`subList(int fromIndex, int toIndex)` Create a sub sequence between the two supplied index
`LazyPStackX<T>`	`takeRight(int num)` Generate a new Traversable that takes the specified number elements from the end of this Traversable
`LazyPStackX<T>`	`takeUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`LazyPStackX<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
`java.lang.Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`
`LazyPStackX<T>`	`toPStack()`
`java.lang.String`	`toString()`
`<R> LazyPStackX<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
`static <U,T> LazyPStackX<T>`	`unfold(U seed, java.util.function.Function<? super U,java.util.Optional<org.jooq.lambda.tuple.Tuple2<T,U>>> unfolder)` Unfold a function into a ListX
`<R> LazyPStackX<R>`	`unit(java.util.Collection<R> col)` Create a new instance of the same colleciton type from the supplied collection
`<R> LazyPStackX<R>`	`unit(R value)`
`<R> LazyPStackX<R>`	`unitIterator(java.util.Iterator<R> it)` Create an IterableFunctor instance of the same type from an Iterator
`LazyPStackX<T>`	`with(int i, T element)` PStackX methods
`<T2,R> LazyPStackX<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> LazyPStackX<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> LazyPStackX<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> LazyPStackX<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> LazyPStackX<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> LazyPStackX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.util.stream.Stream<? extends U> other)` Zip 2 streams into one
`<U,R> LazyPStackX<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> LazyPStackX<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> LazyPStackX<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
`LazyPStackX<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, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.aol.cyclops.data.collections.extensions.persistent.PStackX
coflatMap, drop, fill, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, fromCollection, fromStream, isEfficientOps, narrow, take, toPStackX

Methods inherited from interface com.aol.cyclops.types.To
to

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

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.stream.CyclopsCollectable
allMatch, anyMatch, avg, avg, avgDouble, avgInt, avgLong, bitAnd, bitAnd, bitAndInt, bitAndLong, bitOr, bitOr, bitOrInt, bitOrLong, commonPrefix, commonSuffix, 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
 - LazyPStackX
```
public LazyPStackX(reactor.core.publisher.Flux<T> stream,
 Reducer<org.pcollections.PStack<T>> collector)
```
- Method Detail
 - plusLoop
```
public LazyPStackX<T> plusLoop(int max,
 java.util.function.IntFunction<T> value)
```
 Specified by:
 
 plusLoop in interface LazyFluentCollectionX<T>
 - plusLoop
```
public LazyPStackX<T> plusLoop(java.util.function.Supplier<java.util.Optional<T>> supplier)
```
 Specified by:
 
 plusLoop in interface LazyFluentCollectionX<T>
 - efficientOpsOn
```
public LazyPStackX<T> efficientOpsOn()
```
 Specified by:
 
 efficientOpsOn in interface PStackX<T>
 - efficientOpsOff
```
public LazyPStackX<T> efficientOpsOff()
```
 Specified by:
 
 efficientOpsOff in interface PStackX<T>
 - fromPStack
```
public static <T> LazyPStackX<T> fromPStack(org.pcollections.PStack<T> list,
 Reducer<org.pcollections.PStack<T>> collector)
```
 - fromStreamS
```
public static <T> LazyPStackX<T> fromStreamS(java.util.stream.Stream<T> stream)
```
 Create a LazyPStackX from a Stream
 
 Parameters:
 
 stream - to construct a LazyQueueX from
 
 Returns:
 
 LazyPStackX
 - range
```
public static LazyPStackX<java.lang.Integer> range(int start,
 int end)
```
 Create a LazyPStackX that contains the Integers between start and end
 
 Specified by:
 
 range in interface PStackX<T>
 
 Parameters:
 
 start - Number of range to start from
 
 end - Number for range to end at
 
 Returns:
 
 Range ListX
 - rangeLong
```
public static LazyPStackX<java.lang.Long> rangeLong(long start,
 long end)
```
 Create a LazyPStackX that contains the Longs between start and end
 
 Specified by:
 
 rangeLong in interface PStackX<T>
 
 Parameters:
 
 start - Number of range to start from
 
 end - Number for range to end at
 
 Returns:
 
 Range ListX
 - unfold
```
public static <U,T> LazyPStackX<T> unfold(U seed,
 java.util.function.Function<? super U,java.util.Optional<org.jooq.lambda.tuple.Tuple2<T,U>>> unfolder)
```
 Unfold a function into a ListX
```
 
 LazyPStackX.unfold(1,i->i<=6 ? Optional.of(Tuple.tuple(i,i+1)) : Optional.empty());
 
 //(1,2,3,4,5)
 
 
```
 Specified by:
 
 unfold in interface PStackX<T>
 
 Parameters:
 
 seed - Initial value
 
 unfolder - Iteratively applied function, terminated by an empty Optional
 
 Returns:
 
 ListX generated by unfolder function
 - generate
```
public static <T> LazyPStackX<T> generate(long limit,
 java.util.function.Supplier<T> s)
```
 Generate a LazyPStackX from the provided Supplier up to the provided limit number of times
 
 Specified by:
 
 generate in interface PStackX<T>
 
 Parameters:
 
 limit - Max number of elements to generate
 
 s - Supplier to generate ListX elements
 
 Returns:
 
 ListX generated from the provided Supplier
 - iterate
```
public static <T> LazyPStackX<T> iterate(long limit,
 T seed,
 java.util.function.UnaryOperator<T> f)
```
 Create a LazyPStackX by iterative application of a function to an initial element up to the supplied limit number of times
 
 Specified by:
 
 iterate in interface PStackX<T>
 
 Parameters:
 
 limit - Max number of elements to generate
 
 seed - Initial element
 
 f - Iteratively applied to each element to generate the next element
 
 Returns:
 
 ListX generated by iterative application
 - lazyListXCollector
```
public static <T> java.util.stream.Collector<T,?,LazyPStackX<T>> lazyListXCollector()
```
 Returns:
 
 A collector that generates a LazyPStackX
 - empty
```
public static <T> LazyPStackX<T> empty()
```
 Description copied from interface: PStackX
```
 
 List<String> empty = PStack.empty();
 //or
 
 PStack<String> empty = PStack.empty();
 
 
```
 Specified by:
 
 empty in interface PStackX<T>
 
 Returns:
 
 An empty LazyPStackX
 - of
```
@SafeVarargs
public static <T> LazyPStackX<T> of(T... values)
```
 Create a LazyPStackX from the specified values
```
 
 ListX<Integer> lazy = LazyPStackX.of(1,2,3,4,5);
 
 //lazily map List
 ListX<String> mapped = lazy.map(i->"mapped " +i); 
 
 String value = mapped.get(0); //transformation triggered now
 
 
```
 Specified by:
 
 of in interface PStackX<T>
 
 Parameters:
 
 values - To populate LazyPStackX with
 
 Returns:
 
 LazyPStackX
 - singleton
```
public static <T> LazyPStackX<T> singleton(T value)
```
 Construct a LazyPStackX with a single value
```
 
 ListX<Integer> lazy = LazyPStackX.singleton(5);
 
 
 
```
 Specified by:
 
 singleton in interface PStackX<T>
 
 Parameters:
 
 value - To populate LazyPStackX with
 
 Returns:
 
 LazyPStackX with a single value
 - fromPublisher
```
public static <T> LazyPStackX<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
```
 Construct a LazyPStackX from an Publisher
 
 Specified by:
 
 fromPublisher in interface PStackX<T>
 
 Parameters:
 
 publisher - to construct LazyPStackX from
 
 Returns:
 
 ListX
 - fromIterable
```
public static <T> LazyPStackX<T> fromIterable(java.lang.Iterable<T> it)
```
 Construct LazyPStackX from an Iterable
 
 Specified by:
 
 fromIterable in interface PStackX<T>
 
 Parameters:
 
 it - to construct LazyPStackX from
 
 Returns:
 
 LazyPStackX from Iterable
 - fromIterable
```
public static <T> LazyPStackX<T> fromIterable(Reducer<org.pcollections.PStack<T>> collector,
 java.lang.Iterable<T> it)
```
 Construct a LazyPStackX from an Iterable, using the specified Collector.
 
 Parameters:
 
 collector - To generate Lists from, this can be used to create mutable vs immutable Lists (for example), or control List type (ArrayList, LinkedList)
 
 it - Iterable to construct LazyPStackX from
 
 Returns:
 
 Newly constructed LazyPStackX
 - forEach
```
public void forEach(java.util.function.Consumer<? super T> action)
```
 Specified by:
 
 forEach in interface java.lang.Iterable<T>
 - iterator
```
public java.util.Iterator<T> iterator()
```
 Specified by:
 
 iterator in interface java.lang.Iterable<T>
 
 Specified by:
 
 iterator in interface java.util.Collection<T>
 
 Specified by:
 
 iterator in interface java.util.List<T>
 - size
```
public int size()
```
 Specified by:
 
 size in interface java.util.Collection<T>
 
 Specified by:
 
 size in interface java.util.List<T>
 - contains
```
public boolean contains(java.lang.Object e)
```
 Specified by:
 
 contains in interface java.util.Collection<T>
 
 Specified by:
 
 contains in interface java.util.List<T>
 - equals
```
public boolean equals(java.lang.Object o)
```
 Specified by:
 
 equals in interface java.util.Collection<T>
 
 Specified by:
 
 equals in interface java.util.List<T>
 
 Overrides:
 
 equals in class java.lang.Object
 - isEmpty
```
public boolean isEmpty()
```
 Specified by:
 
 isEmpty in interface java.util.Collection<T>
 
 Specified by:
 
 isEmpty in interface java.util.List<T>
 - hashCode
```
public int hashCode()
```
 Specified by:
 
 hashCode in interface java.util.Collection<T>
 
 Specified by:
 
 hashCode in interface java.util.List<T>
 
 Overrides:
 
 hashCode in class java.lang.Object
 - toArray
```
public java.lang.Object[] toArray()
```
 Specified by:
 
 toArray in interface java.util.Collection<T>
 
 Specified by:
 
 toArray in interface java.util.List<T>
 - removeAll
```
public boolean removeAll(java.util.Collection<?> c)
```
 Specified by:
 
 removeAll in interface java.util.Collection<T>
 
 Specified by:
 
 removeAll in interface java.util.List<T>
 
 Specified by:
 
 removeAll in interface org.pcollections.PCollection<T>
 - toArray
```
public <T> T[] toArray(T[] a)
```
 Specified by:
 
 toArray in interface java.util.Collection<T>
 
 Specified by:
 
 toArray in interface java.util.List<T>
 - add
```
public boolean add(T e)
```
 Specified by:
 
 add in interface java.util.Collection<T>
 
 Specified by:
 
 add in interface java.util.List<T>
 
 Specified by:
 
 add in interface org.pcollections.PCollection<T>
 - remove
```
public boolean remove(java.lang.Object o)
```
 Specified by:
 
 remove in interface java.util.Collection<T>
 
 Specified by:
 
 remove in interface java.util.List<T>
 
 Specified by:
 
 remove in interface org.pcollections.PCollection<T>
 - containsAll
```
public boolean containsAll(java.util.Collection<?> c)
```
 Specified by:
 
 containsAll in interface java.util.Collection<T>
 
 Specified by:
 
 containsAll in interface java.util.List<T>
 - addAll
```
public boolean addAll(java.util.Collection<? extends T> c)
```
 Specified by:
 
 addAll in interface java.util.Collection<T>
 
 Specified by:
 
 addAll in interface java.util.List<T>
 
 Specified by:
 
 addAll in interface org.pcollections.PCollection<T>
 - retainAll
```
public boolean retainAll(java.util.Collection<?> c)
```
 Specified by:
 
 retainAll in interface java.util.Collection<T>
 
 Specified by:
 
 retainAll in interface java.util.List<T>
 
 Specified by:
 
 retainAll in interface org.pcollections.PCollection<T>
 - clear
```
public void clear()
```
 Specified by:
 
 clear in interface java.util.Collection<T>
 
 Specified by:
 
 clear in interface java.util.List<T>
 
 Specified by:
 
 clear in interface org.pcollections.PCollection<T>
 - toString
```
public java.lang.String toString()
```
 Overrides:
 
 toString in class java.lang.Object
 - collect
```
public <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
```
 Specified by:
 
 collect in interface CyclopsCollectable<T>
 
 Specified by:
 
 collect in interface org.jooq.lambda.Collectable<T>
 - count
```
public long count()
```
 Specified by:
 
 count in interface CyclopsCollectable<T>
 
 Specified by:
 
 count in interface org.jooq.lambda.Collectable<T>
 - addAll
```
public boolean addAll(int index,
 java.util.Collection<? extends T> c)
```
 Specified by:
 
 addAll in interface java.util.List<T>
 
 Specified by:
 
 addAll in interface org.pcollections.PSequence<T>
 - replaceAll
```
public void replaceAll(java.util.function.UnaryOperator<T> operator)
```
 Specified by:
 
 replaceAll in interface java.util.List<T>
 - removeIf
```
public boolean removeIf(java.util.function.Predicate<? super T> filter)
```
 Specified by:
 
 removeIf in interface java.util.Collection<T>
 - sort
```
public void sort(java.util.Comparator<? super T> c)
```
 Specified by:
 
 sort in interface java.util.List<T>
 - get
```
public T get(int index)
```
 Specified by:
 
 get in interface java.util.List<T>
 - set
```
public T set(int index,
 T element)
```
 Specified by:
 
 set in interface java.util.List<T>
 
 Specified by:
 
 set in interface org.pcollections.PSequence<T>
 - add
```
public void add(int index,
 T element)
```
 Specified by:
 
 add in interface java.util.List<T>
 
 Specified by:
 
 add in interface org.pcollections.PSequence<T>
 - remove
```
public T remove(int index)
```
 Specified by:
 
 remove in interface java.util.List<T>
 
 Specified by:
 
 remove in interface org.pcollections.PSequence<T>
 - parallelStream
```
public java.util.stream.Stream<T> parallelStream()
```
 Specified by:
 
 parallelStream in interface java.util.Collection<T>
 - indexOf
```
public int indexOf(java.lang.Object o)
```
 Specified by:
 
 indexOf in interface java.util.List<T>
 - lastIndexOf
```
public int lastIndexOf(java.lang.Object o)
```
 Specified by:
 
 lastIndexOf in interface java.util.List<T>
 - listIterator
```
public java.util.ListIterator<T> listIterator()
```
 Specified by:
 
 listIterator in interface java.util.List<T>
 - listIterator
```
public java.util.ListIterator<T> listIterator(int index)
```
 Specified by:
 
 listIterator in interface java.util.List<T>
 - subList
```
public LazyPStackX<T> subList(int fromIndex,
 int toIndex)
```
 Description copied from interface: FluentSequenceX
 
 Create a sub sequence between the two supplied index
 
 Specified by:
 
 subList in interface FluentSequenceX<T>
 
 Specified by:
 
 subList in interface PStackX<T>
 
 Specified by:
 
 subList in interface java.util.List<T>
 
 Specified by:
 
 subList in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 subList in interface org.pcollections.PStack<T>
 
 Parameters:
 
 fromIndex - Index of our sub sequence (inclusive)
 
 toIndex - Index of our sub sequence (exclusive)
 
 Returns:
 - spliterator
```
public java.util.Spliterator<T> spliterator()
```
 Specified by:
 
 spliterator in interface java.lang.Iterable<T>
 
 Specified by:
 
 spliterator in interface java.util.Collection<T>
 
 Specified by:
 
 spliterator in interface java.util.List<T>
 - stream
```
public <X> LazyPStackX<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>
 
 Specified by:
 
 stream in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 stream - Flux to create new collection from
 
 Returns:
 
 New collection from Flux
 - flux
```
public 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>
 
 Specified by:
 
 flux in class AbstractFluentCollectionX<T>
 
 Returns:
 
 Reactor Flux
 - combine
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 combine in interface PStackX<T>
 
 Specified by:
 
 combine in interface Traversable<T>
 
 Overrides:
 
 combine in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - Test to see if two neighbours should be joined
 
 op - Reducer to combine neighbours
 
 Returns:
 
 Combined / Partially Reduced Traversable
 - reverse
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 reverse in interface PStackX<T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 
 Overrides:
 
 reverse in class AbstractFluentCollectionX<T>
 - filter
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 filter in interface PStackX<T>
 
 Specified by:
 
 filter in interface Filterable<T>
 
 Overrides:
 
 filter in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 pred - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - map
```
public <R> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 map in interface PStackX<T>
 
 Specified by:
 
 map in interface Functor<T>
 
 Specified by:
 
 map in interface IterableFunctor<T>
 
 Overrides:
 
 map in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 mapper - Transformation function
 
 Returns:
 
 Transformed Functor
 - flatMap
```
public <R> LazyPStackX<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>
 
 Specified by:
 
 flatMap in interface PersistentCollectionX<T>
 
 Specified by:
 
 flatMap in interface PStackX<T>
 
 Overrides:
 
 flatMap in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 mapper - Transformation function to be applied (and flattened)
 
 Returns:
 
 A collection containing the flattened results of the transformation function
 - limit
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 limit in interface PStackX<T>
 
 Specified by:
 
 limit in interface Traversable<T>
 
 Overrides:
 
 limit in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 num - Limit element size to num
 
 Returns:
 
 Monad converted to Stream with elements up to num
 - skip
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 skip in interface PStackX<T>
 
 Specified by:
 
 skip in interface Traversable<T>
 
 Overrides:
 
 skip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 num - Number of elemenets to skip
 
 Returns:
 
 Stream with specified number of elements skipped
 - takeRight
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 takeRight in interface PStackX<T>
 
 Specified by:
 
 takeRight in interface Traversable<T>
 
 Overrides:
 
 takeRight in class AbstractFluentCollectionX<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 LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 dropRight in interface PStackX<T>
 
 Specified by:
 
 dropRight in interface Traversable<T>
 
 Overrides:
 
 dropRight in class AbstractFluentCollectionX<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 LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 takeWhile in interface PStackX<T>
 
 Specified by:
 
 takeWhile in interface Traversable<T>
 
 Overrides:
 
 takeWhile in class AbstractFluentCollectionX<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 LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 dropWhile in interface PStackX<T>
 
 Specified by:
 
 dropWhile in interface Traversable<T>
 
 Overrides:
 
 dropWhile in class AbstractFluentCollectionX<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 LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 takeUntil in interface PStackX<T>
 
 Specified by:
 
 takeUntil in interface Traversable<T>
 
 Overrides:
 
 takeUntil in class AbstractFluentCollectionX<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 LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 dropUntil in interface PStackX<T>
 
 Specified by:
 
 dropUntil in interface Traversable<T>
 
 Overrides:
 
 dropUntil in class AbstractFluentCollectionX<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> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 trampoline in interface PStackX<T>
 
 Specified by:
 
 trampoline in interface Functor<T>
 
 Overrides:
 
 trampoline in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 mapper - TCO Transformation function
 
 Returns:
 
 Functor transformed by the supplied transformation function
 - slice
```
public LazyPStackX<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface CollectionX<T>
 
 Specified by:
 
 slice in interface PersistentCollectionX<T>
 
 Specified by:
 
 slice in interface PStackX<T>
 
 Specified by:
 
 slice in interface Traversable<T>
 
 Overrides:
 
 slice in class AbstractFluentCollectionX<T>
 - grouped
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 grouped in interface PStackX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Overrides:
 
 grouped in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - grouped
```
public <K,A,D> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 grouped in interface PStackX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Overrides:
 
 grouped in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 classifier - Grouping function
 
 downstream - Collector to create the grouping collection
 
 Returns:
 
 Traversable of grouped data
 - grouped
```
public <K> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 grouped in interface PStackX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Overrides:
 
 grouped in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 classifier - Grouping function
 
 Returns:
 
 Traversable of grouped data
 - zip
```
public  LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface PStackX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 other - Collection to merge with this one
 
 Returns:
 
 Merged collection
 - zip
```
public <U,R> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface PStackX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 other - to zip with
 
 zipper - Zip function
 
 Returns:
 
 Combined zippable
 - sliding
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 sliding in interface PStackX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Overrides:
 
 sliding in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 windowSize - Size of sliding window
 
 Returns:
 
 SequenceM with sliding view
 - sliding
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 sliding in interface PStackX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Overrides:
 
 sliding in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 windowSize - number of elements in each batch
 
 increment - for each window
 
 Returns:
 
 SequenceM with sliding view
 - scanLeft
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 scanLeft in interface PStackX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Overrides:
 
 scanLeft in class AbstractFluentCollectionX<T>
 
 Returns:
 - scanLeft
```
public  LazyPStackX 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 PersistentCollectionX<T>
 
 Specified by:
 
 scanLeft in interface PStackX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Overrides:
 
 scanLeft in class AbstractFluentCollectionX<T>
 - scanRight
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 scanRight in interface PStackX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 
 Overrides:
 
 scanRight in class AbstractFluentCollectionX<T>
 - scanRight
```
public  LazyPStackX 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 PersistentCollectionX<T>
 
 Specified by:
 
 scanRight in interface PStackX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 
 Overrides:
 
 scanRight in class AbstractFluentCollectionX<T>
 - sorted
```
public > LazyPStackX<T> sorted(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 sorted in interface CollectionX<T>
 
 Specified by:
 
 sorted in interface PersistentCollectionX<T>
 
 Specified by:
 
 sorted in interface PStackX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Overrides:
 
 sorted in class AbstractFluentCollectionX<T>
 - plusLazy
```
public LazyPStackX<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>
 
 Overrides:
 
 plusLazy in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 e - Element to add
 
 Returns:
 
 LazyFluentCollectionX with element added
 - plusAllLazy
```
public LazyPStackX<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>
 
 Overrides:
 
 plusAllLazy in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 list - Collection to add
 
 Returns:
 
 LazyFluentCollectionX with Collection added
 - minusLazy
```
public LazyPStackX<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>
 
 Overrides:
 
 minusLazy in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 e - Element to remove
 
 Returns:
 
 LazyFluentCollectionX with element removed
 - minusAllLazy
```
public LazyPStackX<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>
 
 Overrides:
 
 minusAllLazy in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 list - of elements to remove
 
 Returns:
 
 LazyFluentCollectionX with elements removed
 - cycle
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 cycle in interface PStackX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Overrides:
 
 cycle in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 times - Times values should be repeated within a Stream
 
 Returns:
 
 Stream with values repeated
 - cycle
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 cycle in interface PStackX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Overrides:
 
 cycle in class AbstractFluentCollectionX<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 LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 cycleWhile in interface PStackX<T>
 
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Overrides:
 
 cycleWhile in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - cycleUntil
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 cycleUntil in interface PStackX<T>
 
 Specified by:
 
 cycleUntil in interface Traversable<T>
 
 Overrides:
 
 cycleUntil in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - zip
```
public  LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface PStackX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 other - Seq to combine with
 
 Returns:
 
 Combined Zippable
 - zip3
```
public <S,U> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 zip3 in interface PStackX<T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 
 Overrides:
 
 zip3 in class AbstractFluentCollectionX<T>
 - zip4
```
public <T2,T3,T4> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 zip4 in interface PStackX<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 
 Overrides:
 
 zip4 in class AbstractFluentCollectionX<T>
 - zipWithIndex
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 zipWithIndex in interface PStackX<T>
 
 Specified by:
 
 zipWithIndex in interface Traversable<T>
 
 Overrides:
 
 zipWithIndex in class AbstractFluentCollectionX<T>
 - distinct
```
public LazyPStackX<T> distinct()
```
 Specified by:
 
 distinct in interface CollectionX<T>
 
 Specified by:
 
 distinct in interface PersistentCollectionX<T>
 
 Specified by:
 
 distinct in interface PStackX<T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 
 Overrides:
 
 distinct in class AbstractFluentCollectionX<T>
 - sorted
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 sorted in interface PStackX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Overrides:
 
 sorted in class AbstractFluentCollectionX<T>
 - sorted
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 sorted in interface PStackX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Overrides:
 
 sorted in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 c - Compartor to sort with
 
 Returns:
 
 Sorted Stream
 - skipWhile
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 skipWhile in interface PStackX<T>
 
 Specified by:
 
 skipWhile in interface Traversable<T>
 
 Overrides:
 
 skipWhile in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 p - Predicate to skip while true
 
 Returns:
 
 Stream with elements skipped while predicate holds
 - skipUntil
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 skipUntil in interface PStackX<T>
 
 Specified by:
 
 skipUntil in interface Traversable<T>
 
 Overrides:
 
 skipUntil in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 p - Predicate to skip until true
 
 Returns:
 
 Stream with elements skipped until predicate holds
 - limitWhile
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 limitWhile in interface PStackX<T>
 
 Specified by:
 
 limitWhile in interface Traversable<T>
 
 Overrides:
 
 limitWhile in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 p - Limit while predicate is true
 
 Returns:
 
 Stream with limited elements
 - limitUntil
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 limitUntil in interface PStackX<T>
 
 Specified by:
 
 limitUntil in interface Traversable<T>
 
 Overrides:
 
 limitUntil in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 p - Limit until predicate is true
 
 Returns:
 
 Stream with limited elements
 - intersperse
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 intersperse in interface PStackX<T>
 
 Specified by:
 
 intersperse in interface Traversable<T>
 
 Overrides:
 
 intersperse in class AbstractFluentCollectionX<T>
 - shuffle
```
public LazyPStackX<T> shuffle()
```
 Specified by:
 
 shuffle in interface CollectionX<T>
 
 Specified by:
 
 shuffle in interface PersistentCollectionX<T>
 
 Specified by:
 
 shuffle in interface PStackX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 
 Overrides:
 
 shuffle in class AbstractFluentCollectionX<T>
 - skipLast
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 skipLast in interface PStackX<T>
 
 Specified by:
 
 skipLast in interface Traversable<T>
 
 Overrides:
 
 skipLast in class AbstractFluentCollectionX<T>
 
 Returns:
 - limitLast
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 limitLast in interface PStackX<T>
 
 Specified by:
 
 limitLast in interface Traversable<T>
 
 Overrides:
 
 limitLast in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 num - of elements to return (last elements)
 
 Returns:
 
 SequenceM limited to last num elements
 - onEmpty
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 onEmpty in interface PStackX<T>
 
 Specified by:
 
 onEmpty in interface OnEmpty<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 
 Overrides:
 
 onEmpty in class AbstractFluentCollectionX<T>
 
 Returns:
 
 New instance containing value if container is empty, otherwise returns this container
 - onEmptyGet
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 onEmptyGet in interface PStackX<T>
 
 Specified by:
 
 onEmptyGet in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 
 Overrides:
 
 onEmptyGet in class AbstractFluentCollectionX<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> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 onEmptyThrow in interface PStackX<T>
 
 Specified by:
 
 onEmptyThrow in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyThrow in interface Traversable<T>
 
 Overrides:
 
 onEmptyThrow in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 supplier - to create exception from
 
 Returns:
 
 Throw exception if empty, otherwise this container
 - shuffle
```
public LazyPStackX<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface CollectionX<T>
 
 Specified by:
 
 shuffle in interface PersistentCollectionX<T>
 
 Specified by:
 
 shuffle in interface PStackX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 
 Overrides:
 
 shuffle in class AbstractFluentCollectionX<T>
 - ofType
```
public  LazyPStackX 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 PersistentCollectionX<T>
 
 Specified by:
 
 ofType in interface PStackX<T>
 
 Specified by:
 
 ofType in interface Filterable<T>
 
 Overrides:
 
 ofType in class AbstractFluentCollectionX<T>
 - filterNot
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 filterNot in interface PStackX<T>
 
 Specified by:
 
 filterNot in interface Filterable<T>
 
 Overrides:
 
 filterNot in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - notNull
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 notNull in interface PStackX<T>
 
 Specified by:
 
 notNull in interface Filterable<T>
 
 Overrides:
 
 notNull in class AbstractFluentCollectionX<T>
 
 Returns:
 
 Filterable with nulls removed
 - removeAll
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 removeAll in interface PStackX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Overrides:
 
 removeAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 stream - of elements to remove
 
 Returns:
 
 Filterable with all supplied elements removed
 - removeAll
```
public LazyPStackX<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>
 
 Specified by:
 
 removeAll in interface PersistentCollectionX<T>
 
 Specified by:
 
 removeAll in interface PStackX<T>
 
 Overrides:
 
 removeAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 stream - Stream of values to remove
 
 Returns:
 
 Collection with the values removed
 - removeAll
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 removeAll in interface PStackX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Overrides:
 
 removeAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 it - an Iterable of elements to remove
 
 Returns:
 
 Filterable with all supplied elements removed
 - removeAll
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 removeAll in interface PStackX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Overrides:
 
 removeAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 values - to remove
 
 Returns:
 
 Filterable with all supplied values removed
 - retainAll
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 retainAll in interface PStackX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Overrides:
 
 retainAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 it - Iterable of elements to retain
 
 Returns:
 
 Filterable with supplied values retained, and others removed
 - retainAll
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 retainAll in interface PStackX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Overrides:
 
 retainAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 stream - of elements to retain
 
 Returns:
 
 Filterable with supplied values retained, and others removed
 - retainAll
```
public LazyPStackX<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>
 
 Specified by:
 
 retainAll in interface PersistentCollectionX<T>
 
 Specified by:
 
 retainAll in interface PStackX<T>
 
 Overrides:
 
 retainAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 stream - Stream of values to retain
 
 Returns:
 
 Collection with the values retained
 - retainAll
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 retainAll in interface PStackX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Overrides:
 
 retainAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 values - elements to retain
 
 Returns:
 
 Filterable with supplied values retained, and others removed
 - cast
```
public  LazyPStackX 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 PersistentCollectionX<T>
 
 Specified by:
 
 cast in interface PStackX<T>
 
 Specified by:
 
 cast in interface Functor<T>
 
 Overrides:
 
 cast in class AbstractFluentCollectionX<T>
 - patternMatch
```
public <R> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 patternMatch in interface PStackX<T>
 
 Specified by:
 
 patternMatch in interface Functor<T>
 
 Overrides:
 
 patternMatch in class AbstractFluentCollectionX<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 LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 permutations in interface PStackX<T>
 
 Specified by:
 
 permutations in interface ExtendedTraversable<T>
 
 Overrides:
 
 permutations in class AbstractFluentCollectionX<T>
 
 Returns:
 
 Permutations from this ExtendedTraversable
 - combinations
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 combinations in interface PStackX<T>
 
 Specified by:
 
 combinations in interface ExtendedTraversable<T>
 
 Overrides:
 
 combinations in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 size - of combinations
 
 Returns:
 
 All combinations of the elements in this ExtendedTraversable of the specified size
 - combinations
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 combinations in interface PStackX<T>
 
 Specified by:
 
 combinations in interface ExtendedTraversable<T>
 
 Overrides:
 
 combinations in class AbstractFluentCollectionX<T>
 
 Returns:
 
 All combinations of the elements in this ExtendedTraversable
 - grouped
```
public <C extends java.util.Collection<? super T>> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 grouped in interface PStackX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Overrides:
 
 grouped in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 SequenceM batched into collection types by size
 - groupedUntil
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 groupedUntil in interface PStackX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Overrides:
 
 groupedUntil in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedWhile
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 groupedWhile in interface PStackX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Overrides:
 
 groupedWhile in class AbstractFluentCollectionX<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>> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 groupedWhile in interface PStackX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Overrides:
 
 groupedWhile in class AbstractFluentCollectionX<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>> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 groupedUntil in interface PStackX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Overrides:
 
 groupedUntil in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - with
```
public LazyPStackX<T> with(int i,
 T element)
```
 PStackX methods
 
 Specified by:
 
 with in interface FluentSequenceX<T>
 
 Specified by:
 
 with in interface PStackX<T>
 
 Specified by:
 
 with in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 with in interface org.pcollections.PStack<T>
 
 Parameters:
 
 i - Index to replace value at
 
 element - Value to use
 
 Returns:
 
 FluentSequence with value replaced
 
 See Also:
 
 PStack.with(int, java.lang.Object)
 - groupedStatefullyUntil
```
public LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 groupedStatefullyUntil in interface PStackX<T>
 
 Specified by:
 
 groupedStatefullyUntil in interface Traversable<T>
 
 Overrides:
 
 groupedStatefullyUntil in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 Traversable windowed while predicate holds
 - peek
```
public LazyPStackX<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>
 
 Overrides:
 
 peek in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 c - Consumer that recieves each element from this Functor
 
 Returns:
 
 Functor that will peek at each value
 - zip
```
public <U,R> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface PStackX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 other - Seq to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zip
```
public <U,R> LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface PStackX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zip
```
public  LazyPStackX<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 PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface PStackX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - zip
```
public <T2,R> LazyPStackX<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>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 fn - Zip / combining function
 
 publisher - to combine with
 
 Returns:
 
 Combined zippable
 - onEmptySwitch
```
public LazyPStackX<T> onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PStack<T>> supplier)
```
 Description copied from interface: OnEmptySwitch
 Switch to container created by provided Supplier, if current Container empty
```
 
 ListX.empty().onEmptySwitch(()->ListX.of(1));
 
 
```
 Specified by:
 
 onEmptySwitch in interface PStackX<T>
 
 Specified by:
 
 onEmptySwitch in interface OnEmptySwitch<T,org.pcollections.PStack<T>>
 
 Parameters:
 
 supplier - to create replacement container
 
 Returns:
 
 Either this container or if empty, an alternative returned by the provided supplier
 - subList
```
public LazyPStackX<T> subList(int start)
```
 Specified by:
 
 subList in interface org.pcollections.PStack<T>
 - unit
```
public <R> LazyPStackX<R> unit(java.util.Collection<R> col)
```
 Description copied from interface: FluentCollectionX
 
 Create a new instance of the same colleciton type from the supplied collection
 
 Specified by:
 
 unit in interface FluentCollectionX<T>
 
 Specified by:
 
 unit in interface PersistentCollectionX<T>
 
 Specified by:
 
 unit in interface PStackX<T>
 
 Specified by:
 
 unit in interface LazyFluentCollectionX<T>
 
 Parameters:
 
 col - Collection data to populate the new collection
 
 Returns:
 
 Collection as the same type as this collection
 - unit
```
public <R> LazyPStackX<R> unit(R value)
```
 Specified by:
 
 unit in interface CollectionX<T>
 
 Specified by:
 
 unit in interface PStackX<T>
 
 Specified by:
 
 unit in interface Unit<T>
 - unitIterator
```
public <R> LazyPStackX<R> unitIterator(java.util.Iterator<R> it)
```
 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 PStackX<T>
 
 Specified by:
 
 unitIterator in interface IterableFunctor<T>
 
 Specified by:
 
 unitIterator in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 it - Iterator to create new IterableFunctor from
 
 Returns:
 
 New IterableFunctor instance
 - emptyUnit
```
public <R> LazyPStackX<R> emptyUnit()
```
 Specified by:
 
 emptyUnit in interface PersistentCollectionX<T>
 
 Specified by:
 
 emptyUnit in interface PStackX<T>
 - toPStack
```
public LazyPStackX<T> toPStack()
```
 Specified by:
 
 toPStack in interface PStackX<T>
 
 Returns:
 
 This converted to PStack
 - plusInOrder
```
public LazyPStackX<T> plusInOrder(T e)
```
 Description copied from interface: FluentCollectionX
 
 Add an element to the collection
 
 Specified by:
 
 plusInOrder in interface FluentCollectionX<T>
 
 Specified by:
 
 plusInOrder in interface PersistentCollectionX<T>
 
 Specified by:
 
 plusInOrder in interface PStackX<T>
 
 Specified by:
 
 plusInOrder in interface LazyFluentCollectionX<T>
 
 Parameters:
 
 e - Element to add
 
 Returns:
 
 Collection with element added
 - stream
```
public ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface CollectionX<T>
 
 Specified by:
 
 stream in interface PersistentCollectionX<T>
 
 Specified by:
 
 stream in interface PStackX<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 ConvertableSequence<T>
 
 Specified by:
 
 stream in interface TransformerTraversable<T>
 
 Specified by:
 
 stream in interface Traversable<T>
 
 Specified by:
 
 stream in interface java.util.Collection<T>
 
 Returns:
 
 This Traversable converted to a Stream
 - from
```
public <X> LazyPStackX<X> from(java.util.Collection<X> col)
```
 Description copied from interface: CollectionX
 
 Conctruct an Extended Collection from a standard Collection
 
 Specified by:
 
 from in interface CollectionX<T>
 
 Specified by:
 
 from in interface PersistentCollectionX<T>
 
 Specified by:
 
 from in interface PStackX<T>
 
 Specified by:
 
 from in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 col - Collection to extend
 
 Returns:
 
 Extended Collection
 - monoid
```
public <T> Reducer<org.pcollections.PStack<T>> monoid()
```
 Specified by:
 
 monoid in interface PersistentCollectionX<T>
 
 Specified by:
 
 monoid in interface PStackX<T>
 - plus
```
public LazyPStackX<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 FluentSequenceX<T>
 
 Specified by:
 
 plus in interface PStackX<T>
 
 Specified by:
 
 plus in interface LazyFluentCollectionX<T>
 
 Specified by:
 
 plus in interface org.pcollections.PCollection<T>
 
 Specified by:
 
 plus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plus in interface org.pcollections.PStack<T>
 
 Overrides:
 
 plus in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 e - Element to add
 
 Returns:
 
 Collection with element added
 - plus
```
public LazyPStackX<T> plus(int i,
 T e)
```
 Description copied from interface: FluentSequenceX
 
 Add the supplied element at the supplied index
 
 Specified by:
 
 plus in interface FluentSequenceX<T>
 
 Specified by:
 
 plus in interface PStackX<T>
 
 Specified by:
 
 plus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plus in interface org.pcollections.PStack<T>
 
 Parameters:
 
 i - Index to add element at
 
 e - Element to add
 
 Returns:
 
 FluentSequence with element added
 
 See Also:
 
 PStack.plus(int, java.lang.Object)
 - minus
```
public LazyPStackX<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 FluentSequenceX<T>
 
 Specified by:
 
 minus in interface PStackX<T>
 
 Specified by:
 
 minus in interface LazyFluentCollectionX<T>
 
 Specified by:
 
 minus in interface org.pcollections.PCollection<T>
 
 Specified by:
 
 minus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 minus in interface org.pcollections.PStack<T>
 
 Overrides:
 
 minus in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 e - Element to remove
 
 Returns:
 
 Collection with element removed
 - plusAll
```
public LazyPStackX<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 FluentSequenceX<T>
 
 Specified by:
 
 plusAll in interface PStackX<T>
 
 Specified by:
 
 plusAll in interface LazyFluentCollectionX<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PCollection<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PStack<T>
 
 Overrides:
 
 plusAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 list - of elements to add
 
 Returns:
 
 Collection with elements added
 - plusAll
```
public LazyPStackX<T> plusAll(int i,
 java.util.Collection<? extends T> list)
```
 Description copied from interface: FluentSequenceX
 
 Add all of the supplied elements at the supplied index
 
 Specified by:
 
 plusAll in interface FluentSequenceX<T>
 
 Specified by:
 
 plusAll in interface PStackX<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PStack<T>
 
 Parameters:
 
 i - Index to add element at
 
 list - Collection of elements to add
 
 Returns:
 
 FluentSequence with elements added
 
 See Also:
 
 PStack.plusAll(int, java.util.Collection)
 - minusAll
```
public LazyPStackX<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 FluentSequenceX<T>
 
 Specified by:
 
 minusAll in interface PStackX<T>
 
 Specified by:
 
 minusAll in interface LazyFluentCollectionX<T>
 
 Specified by:
 
 minusAll in interface org.pcollections.PCollection<T>
 
 Specified by:
 
 minusAll in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 minusAll in interface org.pcollections.PStack<T>
 
 Overrides:
 
 minusAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 list - of elements to remove
 
 Returns:
 
 Collection with the elements removed
 - minus
```
public LazyPStackX<T> minus(int i)
```
 Description copied from interface: FluentSequenceX
 
 Remove the element at the supplied index
 
 Specified by:
 
 minus in interface FluentSequenceX<T>
 
 Specified by:
 
 minus in interface PStackX<T>
 
 Specified by:
 
 minus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 minus in interface org.pcollections.PStack<T>
 
 Parameters:
 
 i - Index at which to remvoe element
 
 Returns:
 
 FluentSequence with element removed
 
 See Also:
 
 PStack.minus(int)
 - materialize
```
public LazyPStackX<T> materialize()
```
 Specified by:
 
 materialize in interface LazyFluentCollectionX<T>
 
 Returns:
 
 This collection with any queued Lazy Operations materialized

Class LazyPStackX<T>

Nested Class Summary

Nested classes/interfaces inherited from class com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.aol.cyclops.data.collections.extensions.persistent.PStackX

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

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.stream.CyclopsCollectable

Methods inherited from interface org.jooq.lambda.Collectable

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

Constructor Detail

LazyPStackX

Method Detail

plusLoop

plusLoop

efficientOpsOn

efficientOpsOff

fromPStack

fromStreamS

range

rangeLong

unfold

generate

iterate

lazyListXCollector

empty

of

singleton

fromPublisher

fromIterable

fromIterable

forEach

iterator

size

contains

equals

isEmpty

hashCode

toArray

removeAll

toArray

add

remove

containsAll

addAll

retainAll

clear

toString

collect

count

addAll

replaceAll

removeIf

sort

get

set

add

remove

parallelStream

indexOf

lastIndexOf

listIterator

listIterator

subList

spliterator

stream

flux

combine

reverse

filter

map

flatMap

limit

skip