LazyPStackX (cyclops-reactor 8.2.0 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:

com.aol.cyclops.data.collections.extensions.CollectionX<T>, com.aol.cyclops.data.collections.extensions.FluentCollectionX<T>, com.aol.cyclops.data.collections.extensions.FluentSequenceX<T>, com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>, com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>, LazyFluentCollectionX<T>, ReactorConvertable<T>, com.aol.cyclops.types.applicative.zipping.ZippingApplicativable<T>, com.aol.cyclops.types.ExtendedTraversable<T>, com.aol.cyclops.types.Filterable<T>, com.aol.cyclops.types.Foldable<T>, com.aol.cyclops.types.Functor<T>, com.aol.cyclops.types.IterableFilterable<T>, com.aol.cyclops.types.IterableFoldable<T>, com.aol.cyclops.types.IterableFunctor<T>, com.aol.cyclops.types.OnEmpty<T>, com.aol.cyclops.types.OnEmptySwitch<T,org.pcollections.PStack<T>>, com.aol.cyclops.types.Sequential<T>, com.aol.cyclops.types.stream.ConvertableSequence<T>, com.aol.cyclops.types.stream.CyclopsCollectable<T>, com.aol.cyclops.types.TransformerTraversable<T>, com.aol.cyclops.types.Traversable<T>, com.aol.cyclops.types.Unit<T>, com.aol.cyclops.types.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 com.aol.cyclops.data.collections.extensions.persistent.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>>

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)`
`void`	`clear()`
`<R,A> R`	`collect(java.util.stream.Collector<? super T,A,R> collector)`
`LazyPStackX<com.aol.cyclops.control.ReactiveSeq<T>>`	`combinations()`
`LazyPStackX<com.aol.cyclops.control.ReactiveSeq<T>>`	`combinations(int size)`
`LazyPStackX<T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)`
`boolean`	`contains(java.lang.Object e)`
`boolean`	`containsAll(java.util.Collection<?> c)`
`long`	`count()`
`LazyPStackX<T>`	`cycle(int times)`
`LazyPStackX<T>`	`cycle(com.aol.cyclops.Monoid<T> m, int times)`
`LazyPStackX<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)`
`LazyPStackX<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)`
`LazyPStackX<T>`	`distinct()`
`LazyPStackX<T>`	`dropRight(int num)`
`LazyPStackX<T>`	`dropUntil(java.util.function.Predicate<? super T> p)`
`LazyPStackX<T>`	`dropWhile(java.util.function.Predicate<? super T> p)`
`LazyPStackX<T>`	`efficientOpsOff()`
`LazyPStackX<T>`	`efficientOpsOn()`
`static <T> LazyPStackX<T>`	`empty()`
`<R> LazyPStackX<R>`	`emptyUnit()`
`boolean`	`equals(java.lang.Object o)`
`LazyPStackX<T>`	`filter(java.util.function.Predicate<? super T> pred)`
`LazyPStackX<T>`	`filterNot(java.util.function.Predicate<? super T> fn)`
`<R> LazyPStackX<R>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)`
`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)`
`static <T> LazyPStackX<T>`	`fromIterable(java.lang.Iterable<T> it)` Construct LazyPStackX from an Iterable
`static <T> LazyPStackX<T>`	`fromIterable(com.aol.cyclops.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>`	`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)`
`<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)`
`LazyPStackX<com.aol.cyclops.data.collections.extensions.standard.ListX<T>>`	`grouped(int groupSize)`
`<C extends java.util.Collection<? super T>> LazyPStackX<C>`	`grouped(int size, java.util.function.Supplier<C> supplier)`
`LazyPStackX<com.aol.cyclops.data.collections.extensions.standard.ListX<T>>`	`groupedStatefullyUntil(java.util.function.BiPredicate<com.aol.cyclops.data.collections.extensions.standard.ListX<? super T>,? super T> predicate)`
`LazyPStackX<com.aol.cyclops.data.collections.extensions.standard.ListX<T>>`	`groupedUntil(java.util.function.Predicate<? super T> predicate)`
`<C extends java.util.Collection<? super T>> LazyPStackX<C>`	`groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)`
`LazyPStackX<com.aol.cyclops.data.collections.extensions.standard.ListX<T>>`	`groupedWhile(java.util.function.Predicate<? super T> predicate)`
`<C extends java.util.Collection<? super T>> LazyPStackX<C>`	`groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)`
`int`	`hashCode()`
`int`	`indexOf(java.lang.Object o)`
`LazyPStackX<T>`	`intersperse(T value)`
`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)`
`LazyPStackX<T>`	`limitLast(int num)`
`LazyPStackX<T>`	`limitUntil(java.util.function.Predicate<? super T> p)`
`LazyPStackX<T>`	`limitWhile(java.util.function.Predicate<? super T> p)`
`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)`
`LazyPStackX<T>`	`minus(int i)`
`LazyPStackX<T>`	`minus(java.lang.Object e)`
`LazyPStackX<T>`	`minusAll(java.util.Collection<?> list)`
`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> com.aol.cyclops.Reducer<org.pcollections.PStack<T>>`	`monoid()`
`LazyPStackX<T>`	`notNull()`
`static <T> LazyPStackX<T>`	`of(T... values)` Create a LazyPStackX from the specified values
`<U> LazyPStackX<U>`	`ofType(java.lang.Class<? extends U> type)`
`LazyPStackX<T>`	`onEmpty(T value)`
`LazyPStackX<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)`
`LazyPStackX<T>`	`onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PStack<T>> supplier)`
`<X extends java.lang.Throwable> LazyPStackX<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)`
`java.util.stream.Stream<T>`	`parallelStream()`
`<R> LazyPStackX<R>`	`patternMatch(java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<T,R>,com.aol.cyclops.control.Matchable.CheckValue1<T,R>> case1, java.util.function.Supplier<? extends R> otherwise)`
`LazyPStackX<T>`	`peek(java.util.function.Consumer<? super T> c)`
`LazyPStackX<com.aol.cyclops.control.ReactiveSeq<T>>`	`permutations()`
`LazyPStackX<T>`	`plus(int i, T e)`
`LazyPStackX<T>`	`plus(T e)`
`LazyPStackX<T>`	`plusAll(java.util.Collection<? extends T> list)`
`LazyPStackX<T>`	`plusAll(int i, java.util.Collection<? extends T> list)`
`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)`
`LazyPStackX<T>`	`plusLazy(T e)` Lazily add an element to this Collection.
`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)`
`LazyPStackX<T>`	`removeAll(org.jooq.lambda.Seq<? extends T> stream)`
`LazyPStackX<T>`	`removeAll(java.util.stream.Stream<? extends T> stream)`
`LazyPStackX<T>`	`removeAll(T... values)`
`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)`
`LazyPStackX<T>`	`retainAll(org.jooq.lambda.Seq<? extends T> stream)`
`LazyPStackX<T>`	`retainAll(java.util.stream.Stream<? extends T> stream)`
`LazyPStackX<T>`	`retainAll(T... values)`
`LazyPStackX<T>`	`reverse()`
`LazyPStackX<T>`	`scanLeft(com.aol.cyclops.Monoid<T> monoid)`
`<U> LazyPStackX<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)`
`LazyPStackX<T>`	`scanRight(com.aol.cyclops.Monoid<T> monoid)`
`<U> LazyPStackX<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)`
`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)`
`LazyPStackX<T>`	`skipLast(int num)`
`LazyPStackX<T>`	`skipUntil(java.util.function.Predicate<? super T> p)`
`LazyPStackX<T>`	`skipWhile(java.util.function.Predicate<? super T> p)`
`LazyPStackX<T>`	`slice(long from, long to)`
`LazyPStackX<com.aol.cyclops.data.collections.extensions.standard.ListX<T>>`	`sliding(int windowSize)`
`LazyPStackX<com.aol.cyclops.data.collections.extensions.standard.ListX<T>>`	`sliding(int windowSize, int increment)`
`void`	`sort(java.util.Comparator<? super T> c)`
`LazyPStackX<T>`	`sorted()`
`LazyPStackX<T>`	`sorted(java.util.Comparator<? super T> c)`
`<U extends java.lang.Comparable<? super U>> LazyPStackX<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`java.util.Spliterator<T>`	`spliterator()`
`com.aol.cyclops.control.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)`
`LazyPStackX<T>`	`takeRight(int num)`
`LazyPStackX<T>`	`takeUntil(java.util.function.Predicate<? super T> p)`
`LazyPStackX<T>`	`takeWhile(java.util.function.Predicate<? super T> p)`
`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 com.aol.cyclops.control.Trampoline<? extends R>> mapper)`
`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)`
`<R> LazyPStackX<R>`	`unit(R value)`
`<R> LazyPStackX<R>`	`unitIterator(java.util.Iterator<R> it)`
`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)`
`<U> LazyPStackX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)`
`<U,R> LazyPStackX<R>`	`zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`<U> LazyPStackX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<? extends U> other)`
`<U,R> LazyPStackX<R>`	`zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`<U> LazyPStackX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.util.stream.Stream<? extends U> other)`
`<U,R> LazyPStackX<R>`	`zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`<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)`
`<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)`
`LazyPStackX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()`

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
fromCollection, fromStream, isEfficientOps, toPStackX

Methods inherited from interface com.aol.cyclops.data.collections.extensions.CollectionX
collectable, findAny, findFirst, forEach2, forEach2, forEach3, forEach3, 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, 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

- Method Detail
 - efficientOpsOn
```
public LazyPStackX<T> efficientOpsOn()
```
 Specified by:
 
 efficientOpsOn in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 - efficientOpsOff
```
public LazyPStackX<T> efficientOpsOff()
```
 Specified by:
 
 efficientOpsOff in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 - 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 com.aol.cyclops.data.collections.extensions.persistent.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 com.aol.cyclops.data.collections.extensions.persistent.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 com.aol.cyclops.data.collections.extensions.persistent.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 com.aol.cyclops.data.collections.extensions.persistent.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 com.aol.cyclops.data.collections.extensions.persistent.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()
```
 Specified by:
 
 empty in interface com.aol.cyclops.data.collections.extensions.persistent.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 com.aol.cyclops.data.collections.extensions.persistent.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 com.aol.cyclops.data.collections.extensions.persistent.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 com.aol.cyclops.data.collections.extensions.persistent.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 com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Parameters:
 
 it - to construct LazyPStackX from
 
 Returns:
 
 LazyPStackX from Iterable
 - fromIterable
```
public static <T> LazyPStackX<T> fromIterable(com.aol.cyclops.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 com.aol.cyclops.types.stream.CyclopsCollectable<T>
 
 Specified by:
 
 collect in interface org.jooq.lambda.Collectable<T>
 - count
```
public long count()
```
 Specified by:
 
 count in interface com.aol.cyclops.types.stream.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)
```
 Specified by:
 
 subList in interface com.aol.cyclops.data.collections.extensions.FluentSequenceX<T>
 
 Specified by:
 
 subList in interface com.aol.cyclops.data.collections.extensions.persistent.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>
 - 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)
```
 Specified by:
 
 combine in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 combine in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 combine in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 combine in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 combine in class AbstractFluentCollectionX<T>
 - reverse
```
public LazyPStackX<T> reverse()
```
 Specified by:
 
 reverse in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 reverse in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 reverse in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 reverse in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 reverse in class AbstractFluentCollectionX<T>
 - filter
```
public LazyPStackX<T> filter(java.util.function.Predicate<? super T> pred)
```
 Specified by:
 
 filter in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 filter in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 filter in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 filter in interface com.aol.cyclops.types.Filterable<T>
 
 Overrides:
 
 filter in class AbstractFluentCollectionX<T>
 - map
```
public <R> LazyPStackX<R> map(java.util.function.Function<? super T,? extends R> mapper)
```
 Specified by:
 
 map in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 map in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 map in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 map in interface com.aol.cyclops.types.Functor<T>
 
 Specified by:
 
 map in interface com.aol.cyclops.types.IterableFunctor<T>
 
 Overrides:
 
 map in class AbstractFluentCollectionX<T>
 - flatMap
```
public <R> LazyPStackX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
```
 Specified by:
 
 flatMap in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 flatMap in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 flatMap in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Overrides:
 
 flatMap in class AbstractFluentCollectionX<T>
 - limit
```
public LazyPStackX<T> limit(long num)
```
 Specified by:
 
 limit in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 limit in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 limit in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 limit in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 limit in class AbstractFluentCollectionX<T>
 - skip
```
public LazyPStackX<T> skip(long num)
```
 Specified by:
 
 skip in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 skip in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 skip in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 skip in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 skip in class AbstractFluentCollectionX<T>
 - takeRight
```
public LazyPStackX<T> takeRight(int num)
```
 Specified by:
 
 takeRight in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 takeRight in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 takeRight in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 takeRight in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 takeRight in class AbstractFluentCollectionX<T>
 - dropRight
```
public LazyPStackX<T> dropRight(int num)
```
 Specified by:
 
 dropRight in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 dropRight in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 dropRight in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 dropRight in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 dropRight in class AbstractFluentCollectionX<T>
 - takeWhile
```
public LazyPStackX<T> takeWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 takeWhile in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 takeWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 takeWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 takeWhile in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 takeWhile in class AbstractFluentCollectionX<T>
 - dropWhile
```
public LazyPStackX<T> dropWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 dropWhile in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 dropWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 dropWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 dropWhile in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 dropWhile in class AbstractFluentCollectionX<T>
 - takeUntil
```
public LazyPStackX<T> takeUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 takeUntil in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 takeUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 takeUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 takeUntil in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 takeUntil in class AbstractFluentCollectionX<T>
 - dropUntil
```
public LazyPStackX<T> dropUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 dropUntil in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 dropUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 dropUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 dropUntil in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 dropUntil in class AbstractFluentCollectionX<T>
 - trampoline
```
public <R> LazyPStackX<R> trampoline(java.util.function.Function<? super T,? extends com.aol.cyclops.control.Trampoline<? extends R>> mapper)
```
 Specified by:
 
 trampoline in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 trampoline in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 trampoline in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 trampoline in interface com.aol.cyclops.types.Functor<T>
 
 Overrides:
 
 trampoline in class AbstractFluentCollectionX<T>
 - slice
```
public LazyPStackX<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 slice in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 slice in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 slice in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 slice in class AbstractFluentCollectionX<T>
 - grouped
```
public LazyPStackX<com.aol.cyclops.data.collections.extensions.standard.ListX<T>> grouped(int groupSize)
```
 Specified by:
 
 grouped in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 grouped in class AbstractFluentCollectionX<T>
 - 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)
```
 Specified by:
 
 grouped in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 grouped in class AbstractFluentCollectionX<T>
 - 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)
```
 Specified by:
 
 grouped in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 grouped in class AbstractFluentCollectionX<T>
 - zip
```
public  LazyPStackX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
```
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Traversable<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 - zip
```
public <U,R> LazyPStackX<R> zip(java.lang.Iterable<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Traversable<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 - sliding
```
public LazyPStackX<com.aol.cyclops.data.collections.extensions.standard.ListX<T>> sliding(int windowSize)
```
 Specified by:
 
 sliding in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 sliding in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 sliding in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 sliding in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 sliding in class AbstractFluentCollectionX<T>
 - sliding
```
public LazyPStackX<com.aol.cyclops.data.collections.extensions.standard.ListX<T>> sliding(int windowSize,
 int increment)
```
 Specified by:
 
 sliding in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 sliding in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 sliding in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 sliding in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 sliding in class AbstractFluentCollectionX<T>
 - scanLeft
```
public LazyPStackX<T> scanLeft(com.aol.cyclops.Monoid<T> monoid)
```
 Specified by:
 
 scanLeft in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 scanLeft in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 scanLeft in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 scanLeft in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 scanLeft in class AbstractFluentCollectionX<T>
 - scanLeft
```
public  LazyPStackX scanLeft(U seed,
 java.util.function.BiFunction<? super U,? super T,? extends U> function)
```
 Specified by:
 
 scanLeft in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 scanLeft in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 scanLeft in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 scanLeft in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 scanLeft in class AbstractFluentCollectionX<T>
 - scanRight
```
public LazyPStackX<T> scanRight(com.aol.cyclops.Monoid<T> monoid)
```
 Specified by:
 
 scanRight in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 scanRight in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 scanRight in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 scanRight in interface com.aol.cyclops.types.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)
```
 Specified by:
 
 scanRight in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 scanRight in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 scanRight in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 scanRight in interface com.aol.cyclops.types.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 com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 sorted in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 sorted in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 sorted in interface com.aol.cyclops.types.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)
```
 Specified by:
 
 cycle in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 cycle in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 cycle in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 cycle in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 cycle in class AbstractFluentCollectionX<T>
 - cycle
```
public LazyPStackX<T> cycle(com.aol.cyclops.Monoid<T> m,
 int times)
```
 Specified by:
 
 cycle in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 cycle in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 cycle in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 cycle in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 cycle in class AbstractFluentCollectionX<T>
 - cycleWhile
```
public LazyPStackX<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 cycleWhile in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 cycleWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 cycleWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 cycleWhile in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 cycleWhile in class AbstractFluentCollectionX<T>
 - cycleUntil
```
public LazyPStackX<T> cycleUntil(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 cycleUntil in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 cycleUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 cycleUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 cycleUntil in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 cycleUntil in class AbstractFluentCollectionX<T>
 - zip
```
public  LazyPStackX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
```
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Traversable<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 - 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)
```
 Specified by:
 
 zip3 in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 zip3 in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 zip3 in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 zip3 in interface com.aol.cyclops.types.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)
```
 Specified by:
 
 zip4 in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 zip4 in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 zip4 in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 zip4 in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 zip4 in class AbstractFluentCollectionX<T>
 - zipWithIndex
```
public LazyPStackX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()
```
 Specified by:
 
 zipWithIndex in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 zipWithIndex in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 zipWithIndex in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 zipWithIndex in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 zipWithIndex in class AbstractFluentCollectionX<T>
 - distinct
```
public LazyPStackX<T> distinct()
```
 Specified by:
 
 distinct in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 distinct in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 distinct in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 distinct in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 distinct in class AbstractFluentCollectionX<T>
 - sorted
```
public LazyPStackX<T> sorted()
```
 Specified by:
 
 sorted in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 sorted in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 sorted in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 sorted in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 sorted in class AbstractFluentCollectionX<T>
 - sorted
```
public LazyPStackX<T> sorted(java.util.Comparator<? super T> c)
```
 Specified by:
 
 sorted in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 sorted in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 sorted in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 sorted in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 sorted in class AbstractFluentCollectionX<T>
 - skipWhile
```
public LazyPStackX<T> skipWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 skipWhile in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 skipWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 skipWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 skipWhile in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 skipWhile in class AbstractFluentCollectionX<T>
 - skipUntil
```
public LazyPStackX<T> skipUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 skipUntil in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 skipUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 skipUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 skipUntil in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 skipUntil in class AbstractFluentCollectionX<T>
 - limitWhile
```
public LazyPStackX<T> limitWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 limitWhile in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 limitWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 limitWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 limitWhile in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 limitWhile in class AbstractFluentCollectionX<T>
 - limitUntil
```
public LazyPStackX<T> limitUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 limitUntil in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 limitUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 limitUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 limitUntil in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 limitUntil in class AbstractFluentCollectionX<T>
 - intersperse
```
public LazyPStackX<T> intersperse(T value)
```
 Specified by:
 
 intersperse in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 intersperse in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 intersperse in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 intersperse in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 intersperse in class AbstractFluentCollectionX<T>
 - shuffle
```
public LazyPStackX<T> shuffle()
```
 Specified by:
 
 shuffle in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 shuffle in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 shuffle in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 shuffle in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 shuffle in class AbstractFluentCollectionX<T>
 - skipLast
```
public LazyPStackX<T> skipLast(int num)
```
 Specified by:
 
 skipLast in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 skipLast in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 skipLast in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 skipLast in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 skipLast in class AbstractFluentCollectionX<T>
 - limitLast
```
public LazyPStackX<T> limitLast(int num)
```
 Specified by:
 
 limitLast in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 limitLast in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 limitLast in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 limitLast in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 limitLast in class AbstractFluentCollectionX<T>
 - onEmpty
```
public LazyPStackX<T> onEmpty(T value)
```
 Specified by:
 
 onEmpty in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 onEmpty in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 onEmpty in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 onEmpty in interface com.aol.cyclops.types.OnEmpty<T>
 
 Specified by:
 
 onEmpty in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 onEmpty in class AbstractFluentCollectionX<T>
 - onEmptyGet
```
public LazyPStackX<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
 Specified by:
 
 onEmptyGet in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 onEmptyGet in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 onEmptyGet in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 onEmptyGet in interface com.aol.cyclops.types.OnEmpty<T>
 
 Specified by:
 
 onEmptyGet in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 onEmptyGet in class AbstractFluentCollectionX<T>
 - onEmptyThrow
```
public <X extends java.lang.Throwable> LazyPStackX<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
 Specified by:
 
 onEmptyThrow in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 onEmptyThrow in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 onEmptyThrow in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 onEmptyThrow in interface com.aol.cyclops.types.OnEmpty<T>
 
 Specified by:
 
 onEmptyThrow in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 onEmptyThrow in class AbstractFluentCollectionX<T>
 - shuffle
```
public LazyPStackX<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 shuffle in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 shuffle in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 shuffle in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 shuffle in class AbstractFluentCollectionX<T>
 - ofType
```
public  LazyPStackX ofType(java.lang.Class<? extends U> type)
```
 Specified by:
 
 ofType in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 ofType in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 ofType in interface com.aol.cyclops.types.Filterable<T>
 
 Overrides:
 
 ofType in class AbstractFluentCollectionX<T>
 - filterNot
```
public LazyPStackX<T> filterNot(java.util.function.Predicate<? super T> fn)
```
 Specified by:
 
 filterNot in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 filterNot in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 filterNot in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 filterNot in interface com.aol.cyclops.types.Filterable<T>
 
 Overrides:
 
 filterNot in class AbstractFluentCollectionX<T>
 - notNull
```
public LazyPStackX<T> notNull()
```
 Specified by:
 
 notNull in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 notNull in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 notNull in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 notNull in interface com.aol.cyclops.types.Filterable<T>
 
 Overrides:
 
 notNull in class AbstractFluentCollectionX<T>
 - removeAll
```
public LazyPStackX<T> removeAll(java.util.stream.Stream<? extends T> stream)
```
 Specified by:
 
 removeAll in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 removeAll in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 removeAll in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 removeAll in interface com.aol.cyclops.types.IterableFilterable<T>
 
 Overrides:
 
 removeAll in class AbstractFluentCollectionX<T>
 - removeAll
```
public LazyPStackX<T> removeAll(org.jooq.lambda.Seq<? extends T> stream)
```
 Specified by:
 
 removeAll in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 removeAll in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 removeAll in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Overrides:
 
 removeAll in class AbstractFluentCollectionX<T>
 - removeAll
```
public LazyPStackX<T> removeAll(java.lang.Iterable<? extends T> it)
```
 Specified by:
 
 removeAll in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 removeAll in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 removeAll in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 removeAll in interface com.aol.cyclops.types.IterableFilterable<T>
 
 Overrides:
 
 removeAll in class AbstractFluentCollectionX<T>
 - removeAll
```
public LazyPStackX<T> removeAll(T... values)
```
 Specified by:
 
 removeAll in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 removeAll in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 removeAll in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 removeAll in interface com.aol.cyclops.types.IterableFilterable<T>
 
 Overrides:
 
 removeAll in class AbstractFluentCollectionX<T>
 - retainAll
```
public LazyPStackX<T> retainAll(java.lang.Iterable<? extends T> it)
```
 Specified by:
 
 retainAll in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 retainAll in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 retainAll in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 retainAll in interface com.aol.cyclops.types.IterableFilterable<T>
 
 Overrides:
 
 retainAll in class AbstractFluentCollectionX<T>
 - retainAll
```
public LazyPStackX<T> retainAll(java.util.stream.Stream<? extends T> stream)
```
 Specified by:
 
 retainAll in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 retainAll in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 retainAll in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 retainAll in interface com.aol.cyclops.types.IterableFilterable<T>
 
 Overrides:
 
 retainAll in class AbstractFluentCollectionX<T>
 - retainAll
```
public LazyPStackX<T> retainAll(org.jooq.lambda.Seq<? extends T> stream)
```
 Specified by:
 
 retainAll in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 retainAll in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 retainAll in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Overrides:
 
 retainAll in class AbstractFluentCollectionX<T>
 - retainAll
```
public LazyPStackX<T> retainAll(T... values)
```
 Specified by:
 
 retainAll in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 retainAll in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 retainAll in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 retainAll in interface com.aol.cyclops.types.IterableFilterable<T>
 
 Overrides:
 
 retainAll in class AbstractFluentCollectionX<T>
 - cast
```
public  LazyPStackX cast(java.lang.Class<? extends U> type)
```
 Specified by:
 
 cast in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 cast in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 cast in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 cast in interface com.aol.cyclops.types.Functor<T>
 
 Overrides:
 
 cast in class AbstractFluentCollectionX<T>
 - patternMatch
```
public <R> LazyPStackX<R> patternMatch(java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<T,R>,com.aol.cyclops.control.Matchable.CheckValue1<T,R>> case1,
 java.util.function.Supplier<? extends R> otherwise)
```
 Specified by:
 
 patternMatch in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 patternMatch in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 patternMatch in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 patternMatch in interface com.aol.cyclops.types.Functor<T>
 
 Overrides:
 
 patternMatch in class AbstractFluentCollectionX<T>
 - permutations
```
public LazyPStackX<com.aol.cyclops.control.ReactiveSeq<T>> permutations()
```
 Specified by:
 
 permutations in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 permutations in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 permutations in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 permutations in interface com.aol.cyclops.types.ExtendedTraversable<T>
 
 Overrides:
 
 permutations in class AbstractFluentCollectionX<T>
 - combinations
```
public LazyPStackX<com.aol.cyclops.control.ReactiveSeq<T>> combinations(int size)
```
 Specified by:
 
 combinations in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 combinations in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 combinations in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 combinations in interface com.aol.cyclops.types.ExtendedTraversable<T>
 
 Overrides:
 
 combinations in class AbstractFluentCollectionX<T>
 - combinations
```
public LazyPStackX<com.aol.cyclops.control.ReactiveSeq<T>> combinations()
```
 Specified by:
 
 combinations in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 combinations in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 combinations in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 combinations in interface com.aol.cyclops.types.ExtendedTraversable<T>
 
 Overrides:
 
 combinations in class AbstractFluentCollectionX<T>
 - grouped
```
public <C extends java.util.Collection<? super T>> LazyPStackX<C> grouped(int size,
 java.util.function.Supplier<C> supplier)
```
 Specified by:
 
 grouped in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 grouped in class AbstractFluentCollectionX<T>
 - groupedUntil
```
public LazyPStackX<com.aol.cyclops.data.collections.extensions.standard.ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 groupedUntil in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 groupedUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 groupedUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 groupedUntil in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 groupedUntil in class AbstractFluentCollectionX<T>
 - groupedWhile
```
public LazyPStackX<com.aol.cyclops.data.collections.extensions.standard.ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 groupedWhile in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 groupedWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 groupedWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 groupedWhile in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 groupedWhile in class AbstractFluentCollectionX<T>
 - 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)
```
 Specified by:
 
 groupedWhile in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 groupedWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 groupedWhile in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 groupedWhile in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 groupedWhile in class AbstractFluentCollectionX<T>
 - 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)
```
 Specified by:
 
 groupedUntil in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 groupedUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 groupedUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 groupedUntil in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 groupedUntil in class AbstractFluentCollectionX<T>
 - with
```
public LazyPStackX<T> with(int i,
 T element)
```
 PStackX methods
 
 Specified by:
 
 with in interface com.aol.cyclops.data.collections.extensions.FluentSequenceX<T>
 
 Specified by:
 
 with in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 with in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 with in interface org.pcollections.PStack<T>
 - groupedStatefullyUntil
```
public LazyPStackX<com.aol.cyclops.data.collections.extensions.standard.ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<com.aol.cyclops.data.collections.extensions.standard.ListX<? super T>,? super T> predicate)
```
 Specified by:
 
 groupedStatefullyUntil in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 groupedStatefullyUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 groupedStatefullyUntil in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 groupedStatefullyUntil in interface com.aol.cyclops.types.Traversable<T>
 
 Overrides:
 
 groupedStatefullyUntil in class AbstractFluentCollectionX<T>
 - peek
```
public LazyPStackX<T> peek(java.util.function.Consumer<? super T> c)
```
 Specified by:
 
 peek in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 peek in interface com.aol.cyclops.types.Functor<T>
 
 Overrides:
 
 peek in class AbstractFluentCollectionX<T>
 - 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)
```
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Traversable<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 - 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)
```
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Traversable<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 - zip
```
public  LazyPStackX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.util.stream.Stream<? extends U> other)
```
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Traversable<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 - zip
```
public <T2,R> LazyPStackX<R> zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn,
 org.reactivestreams.Publisher<? extends T2> publisher)
```
 Specified by:
 
 zip in interface com.aol.cyclops.types.Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 - onEmptySwitch
```
public LazyPStackX<T> onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PStack<T>> supplier)
```
 Specified by:
 
 onEmptySwitch in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 onEmptySwitch in interface com.aol.cyclops.types.OnEmptySwitch<T,org.pcollections.PStack<T>>
 - 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)
```
 Specified by:
 
 unit in interface com.aol.cyclops.data.collections.extensions.FluentCollectionX<T>
 
 Specified by:
 
 unit in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 unit in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 unit in interface LazyFluentCollectionX<T>
 - unit
```
public <R> LazyPStackX<R> unit(R value)
```
 Specified by:
 
 unit in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 unit in interface com.aol.cyclops.types.Unit<T>
 - unitIterator
```
public <R> LazyPStackX<R> unitIterator(java.util.Iterator<R> it)
```
 Specified by:
 
 unitIterator in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 unitIterator in interface com.aol.cyclops.types.IterableFunctor<T>
 
 Specified by:
 
 unitIterator in class AbstractFluentCollectionX<T>
 - emptyUnit
```
public <R> LazyPStackX<R> emptyUnit()
```
 Specified by:
 
 emptyUnit in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 emptyUnit in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 - toPStack
```
public LazyPStackX<T> toPStack()
```
 Specified by:
 
 toPStack in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Returns:
 
 This converted to PStack
 - plusInOrder
```
public LazyPStackX<T> plusInOrder(T e)
```
 Specified by:
 
 plusInOrder in interface com.aol.cyclops.data.collections.extensions.FluentCollectionX<T>
 
 Specified by:
 
 plusInOrder in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 plusInOrder in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 plusInOrder in interface LazyFluentCollectionX<T>
 - stream
```
public com.aol.cyclops.control.ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 stream in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 stream in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 stream in interface com.aol.cyclops.types.ExtendedTraversable<T>
 
 Specified by:
 
 stream in interface com.aol.cyclops.types.Foldable<T>
 
 Specified by:
 
 stream in interface com.aol.cyclops.types.IterableFunctor<T>
 
 Specified by:
 
 stream in interface com.aol.cyclops.types.Sequential<T>
 
 Specified by:
 
 stream in interface com.aol.cyclops.types.stream.ConvertableSequence<T>
 
 Specified by:
 
 stream in interface com.aol.cyclops.types.TransformerTraversable<T>
 
 Specified by:
 
 stream in interface com.aol.cyclops.types.Traversable<T>
 
 Specified by:
 
 stream in interface java.util.Collection<T>
 - from
```
public <X> LazyPStackX<X> from(java.util.Collection<X> col)
```
 Specified by:
 
 from in interface com.aol.cyclops.data.collections.extensions.CollectionX<T>
 
 Specified by:
 
 from in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 from in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 from in class AbstractFluentCollectionX<T>
 - monoid
```
public <T> com.aol.cyclops.Reducer<org.pcollections.PStack<T>> monoid()
```
 Specified by:
 
 monoid in interface com.aol.cyclops.data.collections.extensions.persistent.PersistentCollectionX<T>
 
 Specified by:
 
 monoid in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 - plus
```
public LazyPStackX<T> plus(T e)
```
 Specified by:
 
 plus in interface com.aol.cyclops.data.collections.extensions.FluentCollectionX<T>
 
 Specified by:
 
 plus in interface com.aol.cyclops.data.collections.extensions.FluentSequenceX<T>
 
 Specified by:
 
 plus in interface com.aol.cyclops.data.collections.extensions.persistent.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>
 - plus
```
public LazyPStackX<T> plus(int i,
 T e)
```
 Specified by:
 
 plus in interface com.aol.cyclops.data.collections.extensions.FluentSequenceX<T>
 
 Specified by:
 
 plus in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 plus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plus in interface org.pcollections.PStack<T>
 - minus
```
public LazyPStackX<T> minus(java.lang.Object e)
```
 Specified by:
 
 minus in interface com.aol.cyclops.data.collections.extensions.FluentCollectionX<T>
 
 Specified by:
 
 minus in interface com.aol.cyclops.data.collections.extensions.FluentSequenceX<T>
 
 Specified by:
 
 minus in interface com.aol.cyclops.data.collections.extensions.persistent.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>
 - plusAll
```
public LazyPStackX<T> plusAll(java.util.Collection<? extends T> list)
```
 Specified by:
 
 plusAll in interface com.aol.cyclops.data.collections.extensions.FluentCollectionX<T>
 
 Specified by:
 
 plusAll in interface com.aol.cyclops.data.collections.extensions.FluentSequenceX<T>
 
 Specified by:
 
 plusAll in interface com.aol.cyclops.data.collections.extensions.persistent.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>
 - plusAll
```
public LazyPStackX<T> plusAll(int i,
 java.util.Collection<? extends T> list)
```
 Specified by:
 
 plusAll in interface com.aol.cyclops.data.collections.extensions.FluentSequenceX<T>
 
 Specified by:
 
 plusAll in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PStack<T>
 - minusAll
```
public LazyPStackX<T> minusAll(java.util.Collection<?> list)
```
 Specified by:
 
 minusAll in interface com.aol.cyclops.data.collections.extensions.FluentCollectionX<T>
 
 Specified by:
 
 minusAll in interface com.aol.cyclops.data.collections.extensions.FluentSequenceX<T>
 
 Specified by:
 
 minusAll in interface com.aol.cyclops.data.collections.extensions.persistent.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>
 - minus
```
public LazyPStackX<T> minus(int i)
```
 Specified by:
 
 minus in interface com.aol.cyclops.data.collections.extensions.FluentSequenceX<T>
 
 Specified by:
 
 minus in interface com.aol.cyclops.data.collections.extensions.persistent.PStackX<T>
 
 Specified by:
 
 minus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 minus in interface org.pcollections.PStack<T>

Class LazyPStackX<T>

Nested Class Summary

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

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

Method Detail

efficientOpsOn

efficientOpsOff

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

takeRight

dropRight

takeWhile

dropWhile

takeUntil

dropUntil

trampoline