PStackX (cyclops-react 1.0.0-FINAL API)

All Superinterfaces:

org.jooq.lambda.Collectable<T>, java.util.Collection<T>, CollectionX<T>, ConvertableSequence<T>, CyclopsCollectable<T>, ExtendedTraversable<T>, Filterable<T>, FluentCollectionX<T>, FluentSequenceX<T>, Foldable<T>, Functor<T>, java.lang.Iterable<T>, IterableFilterable<T>, IterableFoldable<T>, IterableFunctor<T>, java.util.List<T>, OnEmpty<T>, OnEmptySwitch<T,org.pcollections.PStack<T>>, org.pcollections.PCollection<T>, PersistentCollectionX<T>, org.pcollections.PSequence<T>, org.pcollections.PStack<T>, org.reactivestreams.Publisher<T>, Sequential<T>, TransformerTraversable<T>, Traversable<T>, Unit<T>, Zippable<T>, ZippingApplicativable<T>

All Known Implementing Classes:

PStackXImpl
```
public interface PStackX<T>
extends org.pcollections.PStack<T>, PersistentCollectionX<T>, FluentSequenceX<T>, OnEmptySwitch<T,org.pcollections.PStack<T>>
```

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <U> PStackX<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default PStackX<ReactiveSeq<T>>`	`combinations()` `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]]`
`default PStackX<ReactiveSeq<T>>`	`combinations(int size)` `ReactiveSeq.of(1,2,3).combinations(2) //ReactiveSeq[ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]]`
`default PStackX<T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)` Combine two adjacent elements in a PStackX using the supplied BinaryOperator This is a stateful grouping & reduction operation.
`default PStackX<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`default PStackX<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`default PStackX<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`default PStackX<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`default PStackX<T>`	`distinct()`
`default PStackX<T>`	`dropRight(int num)`
`default PStackX<T>`	`dropUntil(java.util.function.Predicate<? super T> p)`
`default PStackX<T>`	`dropWhile(java.util.function.Predicate<? super T> p)`
`PStackX<T>`	`efficientOpsOff()`
`PStackX<T>`	`efficientOpsOn()`
`static <T> PStackX<T>`	`empty()` `List<String> empty = PStack.empty(); //or PStack<String> empty = PStack.empty();`
`default <R> PStackX<R>`	`emptyUnit()`
`default PStackX<T>`	`filter(java.util.function.Predicate<? super T> pred)` Keep only elements for which the supplied predicates hold e.g.
`default PStackX<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`default <R> PStackX<R>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)`
`default <X> PStackX<X>`	`from(java.util.Collection<X> col)`
`static <T> PStackX<T>`	`fromCollection(java.util.Collection<T> values)` `List<String> list = PStacks.of(Arrays.asList("a","b","c")); // or PStack<String> list = PStacks.of(Arrays.asList("a","b","c"));`
`static <T> PStackX<T>`	`fromIterable(java.lang.Iterable<T> iterable)`
`static <T> PStackX<T>`	`fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)` Construct a PStackX from an Publisher
`static <T> PStackX<T>`	`fromStream(java.util.stream.Stream<T> stream)` Reduce (immutable Collection) a Stream to a PStack, note for efficiency reasons, the produced PStack is reversed.
`static <T> PStackX<T>`	`generate(long limit, java.util.function.Supplier<T> s)` Generate a PStackX from the provided Supplier up to the provided limit number of times
`default <K> PStackX<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier)`
`default <K,A,D> PStackX<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)`
`default PStackX<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`default <C extends java.util.Collection<? super T>> PStackX<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
`default PStackX<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.
`default PStackX<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
`default <C extends java.util.Collection<? super T>> PStackX<C>`	`groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a SequenceM batched by a Collection, where each batch is populated until the predicate holds
`default PStackX<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
`default <C extends java.util.Collection<? super T>> PStackX<C>`	`groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds
`default PStackX<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`boolean`	`isEfficientOps()`
`static <T> PStackX<T>`	`iterate(long limit, T seed, java.util.function.UnaryOperator<T> f)` Create a PStackX by iterative application of a function to an initial element up to the supplied limit number of times
`default PStackX<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`default PStackX<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`default PStackX<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.
`default PStackX<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
`default <R> PStackX<R>`	`map(java.util.function.Function<? super T,? extends R> mapper)` Transform this functor using the supplied transformation function
`PStackX<T>`	`minus(int i)`
`PStackX<T>`	`minus(java.lang.Object remove)` Remove the specified element from this collection
`PStackX<T>`	`minusAll(java.util.Collection<?> list)` Remove all the specified elements from this collection
`default <T> Reducer<org.pcollections.PStack<T>>`	`monoid()`
`default PStackX<T>`	`notNull()` Filter elements retaining only values which are not null
`static <T> PStackX<T>`	`of(T... values)` Construct a PStack from the provided values
`default <U> PStackX<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`default PStackX<T>`	`onEmpty(T value)` If this Container instance is empty, create a new instance containing the provided value
`default PStackX<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
`default PStackX<T>`	`onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PStack<T>> supplier)` Switch to container created by provided Supplier, if current Container empty
`default <X extends java.lang.Throwable> PStackX<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is empty, throw the exception returned by the provided Supplier
`default <R> PStackX<R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`default PStackX<ReactiveSeq<T>>`	`permutations()` Generate the permutations based on values in the ReactiveSeq Makes use of Streamable to store intermediate stages in a collection
`PStackX<T>`	`plus(int i, T e)`
`PStackX<T>`	`plus(T e)` Add an element to this Collection
`PStackX<T>`	`plusAll(java.util.Collection<? extends T> list)` Add all supplied elements to this Collection
`PStackX<T>`	`plusAll(int i, java.util.Collection<? extends T> list)`
`default PStackX<T>`	`plusInOrder(T e)` Add an element to the collection
`static PStackX<java.lang.Integer>`	`range(int start, int end)` Create a PStackX that contains the Integers between start and end
`static PStackX<java.lang.Long>`	`rangeLong(long start, long end)` Create a PStackX that contains the Longs between start and end
`default PStackX<T>`	`removeAll(java.lang.Iterable<? extends T> it)` Remove all elements in the supplied Iterable from this filterable
`default PStackX<T>`	`removeAll(org.jooq.lambda.Seq<? extends T> stream)`
`default PStackX<T>`	`removeAll(java.util.stream.Stream<? extends T> stream)` Remove all elements in the supplied Stream from this filterable
`default PStackX<T>`	`removeAll(T... values)` Remove all supplied elements from this filterable
`default PStackX<T>`	`retainAll(java.lang.Iterable<? extends T> it)` Retain only the supplied elements in the returned Filterable
`default PStackX<T>`	`retainAll(org.jooq.lambda.Seq<? extends T> stream)`
`default PStackX<T>`	`retainAll(java.util.stream.Stream<? extends T> seq)` Retain only the supplied elements in the returned Filterable
`default PStackX<T>`	`retainAll(T... values)` Retain only the supplied elements in the returned Filterable
`default PStackX<T>`	`reverse()`
`default PStackX<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`default <U> PStackX<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`default PStackX<T>`	`scanRight(Monoid<T> monoid)` Scan right
`default <U> PStackX<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`default PStackX<T>`	`shuffle()`
`default PStackX<T>`	`shuffle(java.util.Random random)`
`static <T> PStackX<T>`	`singleton(T value)` Construct a PStack containing a single value
`default PStackX<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`default PStackX<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`default PStackX<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
`default PStackX<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 *
`default PStackX<T>`	`slice(long from, long to)`
`default PStackX<ListX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`default PStackX<ListX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`default PStackX<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`default PStackX<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)));`
`default <U extends java.lang.Comparable<? super U>> PStackX<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`default ReactiveSeq<T>`	`stream()`
`PStackX<T>`	`subList(int start, int end)`
`default PStackX<T>`	`takeRight(int num)`
`default PStackX<T>`	`takeUntil(java.util.function.Predicate<? super T> p)`
`default PStackX<T>`	`takeWhile(java.util.function.Predicate<? super T> p)`
`default org.pcollections.PStack<T>`	`toPStack()`
`default PStackX<T>`	`toPStackX()`
`default <R> PStackX<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> PStackX<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 PStackX
`default <R> PStackX<R>`	`unit(java.util.Collection<R> col)` Create a new instance of the same colleciton type from the supplied collection
`default <R> PStackX<R>`	`unit(R value)`
`default <R> PStackX<R>`	`unitIterator(java.util.Iterator<R> it)` Create an IterableFunctor instance of the same type from an Iterator
`PStackX<T>`	`with(int i, T e)`
`default <U> PStackX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)` Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
`default <U,R> PStackX<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
`default <U> PStackX<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
`default <U,R> PStackX<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
`default <U> PStackX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.util.stream.Stream<? extends U> other)` Zip 2 streams into one
`default <U,R> PStackX<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
`default <S,U> PStackX<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
`default <T2,T3,T4> PStackX<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
`default PStackX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream

Methods inherited from interface org.pcollections.PStack
subList

Methods inherited from interface org.pcollections.PSequence
add, addAll, remove, set

Methods inherited from interface org.pcollections.PCollection
add, addAll, clear, remove, removeAll, retainAll

Methods inherited from interface java.util.List
add, addAll, clear, contains, containsAll, equals, get, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, remove, removeAll, replaceAll, retainAll, size, sort, spliterator, toArray, toArray

Methods inherited from interface com.aol.cyclops.data.collections.extensions.CollectionX
collectable, findAny, findFirst, forEach2, forEach2, forEach3, forEach3, getAtIndex, groupBy, head, headAndTail, peek, 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 java.util.Collection
parallelStream, removeIf

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable
allMatch, anyMatch, avg, avg, avgDouble, avgInt, avgLong, bitAnd, bitAnd, bitAndInt, bitAndLong, bitOr, bitOr, bitOrInt, bitOrLong, collect, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, max, max, max, maxAll, maxAll, maxAll, maxAll, maxAllBy, maxAllBy, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, min, minAll, minAll, minAll, minAll, minAllBy, minAllBy, minBy, minBy, mode, modeAll, modeAllBy, modeBy, noneMatch, percentile, percentile, percentileBy, percentileBy, sum, sum, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toMap, toSet, toSet, toString, toString

Methods inherited from interface org.jooq.lambda.Collectable
collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect

- Method Detail
 - range
```
static PStackX<java.lang.Integer> range(int start,
 int end)
```
 Create a PStackX that contains the Integers between start and end
 
 Parameters:
 
 start - Number of range to start from
 
 end - Number for range to end at
 
 Returns:
 
 Range PStackX
 - rangeLong
```
static PStackX<java.lang.Long> rangeLong(long start,
 long end)
```
 Create a PStackX that contains the Longs between start and end
 
 Parameters:
 
 start - Number of range to start from
 
 end - Number for range to end at
 
 Returns:
 
 Range PStackX
 - unfold
```
static <U,T> PStackX<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 PStackX
```
 
 PStackX.unfold(1,i->i<=6 ? Optional.of(Tuple.tuple(i,i+1)) : Optional.empty());
 
 //(1,2,3,4,5)
 
 
```
 Parameters:
 
 seed - Initial value
 
 unfolder - Iteratively applied function, terminated by an empty Optional
 
 Returns:
 
 PStackX generated by unfolder function
 - generate
```
static <T> PStackX<T> generate(long limit,
 java.util.function.Supplier<T> s)
```
 Generate a PStackX from the provided Supplier up to the provided limit number of times
 
 Parameters:
 
 limit - Max number of elements to generate
 
 s - Supplier to generate PStackX elements
 
 Returns:
 
 PStackX generated from the provided Supplier
 - iterate
```
static <T> PStackX<T> iterate(long limit,
 T seed,
 java.util.function.UnaryOperator<T> f)
```
 Create a PStackX by iterative application of a function to an initial element up to the supplied limit number of times
 
 Parameters:
 
 limit - Max number of elements to generate
 
 seed - Initial element
 
 f - Iteratively applied to each element to generate the next element
 
 Returns:
 
 PStackX generated by iterative application
 - of
```
static <T> PStackX<T> of(T... values)
```
 Construct a PStack from the provided values
```
 
 List<String> list = PStacks.of("a","b","c");
 
 // or
 
 PStack<String> list = PStacks.of("a","b","c");
 
 
 
 
```
 Parameters:
 
 values - To add to PStack
 
 Returns:
 
 new PStack
 - fromPublisher
```
static <T> PStackX<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
```
 Construct a PStackX from an Publisher
 
 Parameters:
 
 publisher - to construct PStackX from
 
 Returns:
 
 PStackX
 - fromIterable
```
static <T> PStackX<T> fromIterable(java.lang.Iterable<T> iterable)
```
 - fromCollection
```
static <T> PStackX<T> fromCollection(java.util.Collection<T> values)
```
```
 
 List<String> list = PStacks.of(Arrays.asList("a","b","c"));
 
 // or
 
 PStack<String> list = PStacks.of(Arrays.asList("a","b","c"));
 
 
 
```
 Specified by:
 
 fromCollection in interface CollectionX<T>
 
 Parameters:
 
 values - To add to PStack
 
 Returns:
 - empty
```
static <T> PStackX<T> empty()
```
```
 
 List<String> empty = PStack.empty();
 //or
 
 PStack<String> empty = PStack.empty();
 
 
```
 Returns:
 
 an empty PStack
 - singleton
```
static <T> PStackX<T> singleton(T value)
```
 Construct a PStack containing a single value List<String> single = PStacks.singleton("1"); //or PStack<String> single = PStacks.singleton("1");
 
 Parameters:
 
 value - Single value for PVector
 
 Returns:
 
 PVector with a single value
 - fromStream
```
static <T> PStackX<T> fromStream(java.util.stream.Stream<T> stream)
```
 Reduce (immutable Collection) a Stream to a PStack, note for efficiency reasons, the produced PStack is reversed.
```
 
 PStack<Integer> list = PStacks.fromStream(Stream.of(1,2,3));
 
 //list = [3,2,1]
 
```
 Parameters:
 
 stream - to convert to a PVector
 
 Returns:
 - toPStackX
```
default PStackX<T> toPStackX()
```
 Specified by:
 
 toPStackX in interface ConvertableSequence<T>
 - combine
```
default PStackX<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
 java.util.function.BinaryOperator<T> op)
```
 Combine two adjacent elements in a PStackX using the supplied BinaryOperator This is a stateful grouping & reduction operation. The output of a combination may in turn be combined with it's neighbor
```
 
 PStackX.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 Traversable<T>
 
 Parameters:
 
 predicate - Test to see if two neighbors should be joined
 
 op - Reducer to combine neighbors
 
 Returns:
 
 Combined / Partially Reduced PStackX
 - unit
```
default <R> PStackX<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>
 
 Parameters:
 
 col - Collection data to populate the new collection
 
 Returns:
 
 Collection as the same type as this collection
 - unit
```
default <R> PStackX<R> unit(R value)
```
 Specified by:
 
 unit in interface Unit<T>
 - unitIterator
```
default <R> PStackX<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 IterableFunctor<T>
 
 Parameters:
 
 it - Iterator to create new IterableFunctor from
 
 Returns:
 
 New IterableFunctor instance
 - emptyUnit
```
default <R> PStackX<R> emptyUnit()
```
 Specified by:
 
 emptyUnit in interface PersistentCollectionX<T>
 - toPStack
```
default org.pcollections.PStack<T> toPStack()
```
 - plusInOrder
```
default PStackX<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>
 
 Parameters:
 
 e - Element to add
 
 Returns:
 
 Collection with element added
 - stream
```
default ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface java.util.Collection<T>
 
 Specified by:
 
 stream in interface CollectionX<T>
 
 Specified by:
 
 stream in interface ConvertableSequence<T>
 
 Specified by:
 
 stream in interface ExtendedTraversable<T>
 
 Specified by:
 
 stream in interface Foldable<T>
 
 Specified by:
 
 stream in interface IterableFunctor<T>
 
 Specified by:
 
 stream in interface PersistentCollectionX<T>
 
 Specified by:
 
 stream in interface Sequential<T>
 
 Specified by:
 
 stream in interface TransformerTraversable<T>
 
 Specified by:
 
 stream in interface Traversable<T>
 - from
```
default <X> PStackX<X> from(java.util.Collection<X> col)
```
 Specified by:
 
 from in interface CollectionX<T>
 
 Specified by:
 
 from in interface PersistentCollectionX<T>
 
 Returns:
 - monoid
```
default <T> Reducer<org.pcollections.PStack<T>> monoid()
```
 Specified by:
 
 monoid in interface PersistentCollectionX<T>
 - reverse
```
default PStackX<T> reverse()
```
 Specified by:
 
 reverse in interface CollectionX<T>
 
 Specified by:
 
 reverse in interface PersistentCollectionX<T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 - efficientOpsOn
```
PStackX<T> efficientOpsOn()
```
 - efficientOpsOff
```
PStackX<T> efficientOpsOff()
```
 - isEfficientOps
```
boolean isEfficientOps()
```
 - filter
```
default PStackX<T> filter(java.util.function.Predicate<? super T> pred)
```
 Description copied from interface: Filterable
 Keep only elements for which the supplied predicates hold e.g.
```
 
 
 of(1,2,3).filter(i->i>2);
 
 //[3]
 
 
 
```
 Specified by:
 
 filter in interface CollectionX<T>
 
 Specified by:
 
 filter in interface Filterable<T>
 
 Specified by:
 
 filter in interface PersistentCollectionX<T>
 
 Parameters:
 
 pred - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - map
```
default <R> PStackX<R> map(java.util.function.Function<? super T,? extends R> mapper)
```
 Description copied from interface: Functor
 Transform this functor using the supplied transformation function
```
 
 
 
 of(1,2,3).map(i->i*2)
 
 //[2,4,6]
 
 
 
```
 Specified by:
 
 map in interface CollectionX<T>
 
 Specified by:
 
 map in interface Functor<T>
 
 Specified by:
 
 map in interface IterableFunctor<T>
 
 Specified by:
 
 map in interface PersistentCollectionX<T>
 
 Parameters:
 
 mapper - Transformation function
 
 Returns:
 
 Transformed Functor
 - flatMap
```
default <R> PStackX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
```
 Specified by:
 
 flatMap in interface CollectionX<T>
 
 Specified by:
 
 flatMap in interface PersistentCollectionX<T>
 
 Returns:
 - limit
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 num - Limit element size to num
 
 Returns:
 
 Monad converted to Stream with elements up to num
 - skip
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 num - Number of elemenets to skip
 
 Returns:
 
 Stream with specified number of elements skipped
 - takeRight
```
default PStackX<T> takeRight(int num)
```
 Specified by:
 
 takeRight in interface CollectionX<T>
 
 Specified by:
 
 takeRight in interface PersistentCollectionX<T>
 
 Specified by:
 
 takeRight in interface Traversable<T>
 - dropRight
```
default PStackX<T> dropRight(int num)
```
 Specified by:
 
 dropRight in interface CollectionX<T>
 
 Specified by:
 
 dropRight in interface PersistentCollectionX<T>
 
 Specified by:
 
 dropRight in interface Traversable<T>
 - takeWhile
```
default PStackX<T> takeWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 takeWhile in interface CollectionX<T>
 
 Specified by:
 
 takeWhile in interface PersistentCollectionX<T>
 
 Specified by:
 
 takeWhile in interface Traversable<T>
 - dropWhile
```
default PStackX<T> dropWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 dropWhile in interface CollectionX<T>
 
 Specified by:
 
 dropWhile in interface PersistentCollectionX<T>
 
 Specified by:
 
 dropWhile in interface Traversable<T>
 - takeUntil
```
default PStackX<T> takeUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 takeUntil in interface CollectionX<T>
 
 Specified by:
 
 takeUntil in interface PersistentCollectionX<T>
 
 Specified by:
 
 takeUntil in interface Traversable<T>
 - dropUntil
```
default PStackX<T> dropUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 dropUntil in interface CollectionX<T>
 
 Specified by:
 
 dropUntil in interface PersistentCollectionX<T>
 
 Specified by:
 
 dropUntil in interface Traversable<T>
 - trampoline
```
default <R> PStackX<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
```
 Description copied from interface: PersistentCollectionX
 Performs a map operation that can call a recursive method without running out of stack space
```
 
 ReactiveSeq.of(10,20,30,40)
 		 .trampoline(i-> fibonacci(i))
 		 .forEach(System.out::println); 
 		 
 Trampoline<Long> fibonacci(int i){
 	return fibonacci(i,1,0);
 }
 Trampoline<Long> fibonacci(int n, long a, long b) {
 	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
 }		 
 		 
 55
 6765
 832040
 102334155
 
 
 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
 		 .trampoline(i-> fibonacci(i))
 		 .forEach(System.out::println);
 		 
 		 
 completes successfully
 
```
 Specified by:
 
 trampoline in interface CollectionX<T>
 
 Specified by:
 
 trampoline in interface Functor<T>
 
 Specified by:
 
 trampoline in interface PersistentCollectionX<T>
 
 Parameters:
 
 mapper - TCO Transformation function
 
 Returns:
 
 Functor transformed by the supplied transformation function
 - slice
```
default PStackX<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 Traversable<T>
 - sorted
```
default > PStackX<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 Traversable<T>
 - minusAll
```
PStackX<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 org.pcollections.PCollection<T>
 
 Specified by:
 
 minusAll in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 minusAll in interface org.pcollections.PStack<T>
 
 Parameters:
 
 list - of elements to remove
 
 Returns:
 
 Collection with the elements removed
 - minus
```
PStackX<T> minus(java.lang.Object remove)
```
 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 org.pcollections.PCollection<T>
 
 Specified by:
 
 minus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 minus in interface org.pcollections.PStack<T>
 
 Parameters:
 
 remove - Element to remove
 
 Returns:
 
 Collection with element removed
 - with
```
PStackX<T> with(int i,
 T e)
```
 Specified by:
 
 with in interface FluentSequenceX<T>
 
 Specified by:
 
 with in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 with in interface org.pcollections.PStack<T>
 
 Parameters:
 
 i -
 
 e -
 
 Returns:
 
 See Also:
 
 PStack.with(int, java.lang.Object)
 - plus
```
PStackX<T> plus(int i,
 T e)
```
 Specified by:
 
 plus in interface FluentSequenceX<T>
 
 Specified by:
 
 plus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plus in interface org.pcollections.PStack<T>
 
 Parameters:
 
 i -
 
 e -
 
 Returns:
 
 See Also:
 
 PStack.plus(int, java.lang.Object)
 - plus
```
PStackX<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 org.pcollections.PCollection<T>
 
 Specified by:
 
 plus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plus in interface org.pcollections.PStack<T>
 
 Parameters:
 
 e - Element to add
 
 Returns:
 
 Collection with element added
 - plusAll
```
PStackX<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 org.pcollections.PCollection<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PStack<T>
 
 Parameters:
 
 list - of elements to add
 
 Returns:
 
 Collection with elements added
 - plusAll
```
PStackX<T> plusAll(int i,
 java.util.Collection<? extends T> list)
```
 Specified by:
 
 plusAll in interface FluentSequenceX<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PStack<T>
 
 Parameters:
 
 i -
 
 list -
 
 Returns:
 
 See Also:
 
 PStack.plusAll(int, java.util.Collection)
 - minus
```
PStackX<T> minus(int i)
```
 Specified by:
 
 minus in interface FluentSequenceX<T>
 
 Specified by:
 
 minus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 minus in interface org.pcollections.PStack<T>
 
 Parameters:
 
 i -
 
 Returns:
 
 See Also:
 
 PStack.minus(int)
 - subList
```
PStackX<T> subList(int start,
 int end)
```
 Specified by:
 
 subList in interface FluentSequenceX<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>
 - grouped
```
default PStackX<ListX<T>> grouped(int groupSize)
```
 Description copied from interface: Traversable
 Group elements in a Stream
```
 {
 @code
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(4, 5, 6));
 
 }
 
```
 Specified by:
 
 grouped in interface CollectionX<T>
 
 Specified by:
 
 grouped in interface PersistentCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - grouped
```
default <K,A,D> PStackX<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 CollectionX<T>
 
 Specified by:
 
 grouped in interface PersistentCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 - grouped
```
default <K> PStackX<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 CollectionX<T>
 
 Specified by:
 
 grouped in interface PersistentCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 - zip
```
default  PStackX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
 
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Iterable to combine with
 
 Returns:
 - zip
```
default <U,R> PStackX<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 Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - to zip with
 
 zipper - Zip function
 
 Returns:
 
 Combined zippable
 - zip
```
default <U,R> PStackX<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 Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Seq to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zip
```
default <U,R> PStackX<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 Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - permutations
```
default PStackX<ReactiveSeq<T>> permutations()
```
 Description copied from interface: ExtendedTraversable
 
 Generate the permutations based on values in the ReactiveSeq Makes use of Streamable to store intermediate stages in a collection
 
 Specified by:
 
 permutations in interface CollectionX<T>
 
 Specified by:
 
 permutations in interface ExtendedTraversable<T>
 
 Specified by:
 
 permutations in interface PersistentCollectionX<T>
 
 Returns:
 
 Permutations from this ReactiveSeq
 - combinations
```
default PStackX<ReactiveSeq<T>> combinations(int size)
```
 Description copied from interface: ExtendedTraversable
```
 
 ReactiveSeq.of(1,2,3).combinations(2)
 
 //ReactiveSeq[ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]]
 
 
```
 Specified by:
 
 combinations in interface CollectionX<T>
 
 Specified by:
 
 combinations in interface ExtendedTraversable<T>
 
 Specified by:
 
 combinations in interface PersistentCollectionX<T>
 
 Parameters:
 
 size - of combinations
 
 Returns:
 
 All combinations of the elements in this stream of the specified size
 - combinations
```
default PStackX<ReactiveSeq<T>> combinations()
```
 Description copied from interface: ExtendedTraversable
```
 
 ReactiveSeq.of(1,2,3).combinations()
 
 //ReactiveSeq[ReactiveSeq[],ReactiveSeq[1],ReactiveSeq[2],ReactiveSeq[3].ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]
 			,ReactiveSeq[1,2,3]]
 
 
```
 Specified by:
 
 combinations in interface CollectionX<T>
 
 Specified by:
 
 combinations in interface ExtendedTraversable<T>
 
 Specified by:
 
 combinations in interface PersistentCollectionX<T>
 
 Returns:
 
 All combinations of the elements in this stream
 - sliding
```
default PStackX<ListX<T>> sliding(int windowSize)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 {
 @code
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(2).collect(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2));
 assertThat(list.get(1), hasItems(2, 3));
 
 }
 
 
```
 Specified by:
 
 sliding in interface CollectionX<T>
 
 Specified by:
 
 sliding in interface PersistentCollectionX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - Size of sliding window
 
 Returns:
 
 SequenceM with sliding view
 - sliding
```
default PStackX<ListX<T>> sliding(int windowSize,
 int increment)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 {
 @code
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(3, 4, 5));
 
 }
 
 
```
 Specified by:
 
 sliding in interface CollectionX<T>
 
 Specified by:
 
 sliding in interface PersistentCollectionX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - number of elements in each batch
 
 increment - for each window
 
 Returns:
 
 SequenceM with sliding view
 - scanLeft
```
default  PStackX 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 Traversable<T>
 - scanRight
```
default  PStackX 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 Traversable<T>
 - scanLeft
```
default PStackX<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 Traversable<T>
 
 Returns:
 - scanRight
```
default PStackX<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 Traversable<T>
 - cycle
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 times - Times values should be repeated within a Stream
 
 Returns:
 
 Stream with values repeated
 - cycle
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 m - Monoid to be used in reduction
 
 times - Number of times value should be repeated
 
 Returns:
 
 Stream with reduced values repeated
 - cycleWhile
```
default PStackX<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Repeat in a Stream while specified predicate holds
```
 {
 @code
 MutableInt count = MutableInt.of(0);
 ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6).collect(Collectors.toList());
 
 // List(1,2,2,1,2,2)
 }
 
```
 Specified by:
 
 cycleWhile in interface CollectionX<T>
 
 Specified by:
 
 cycleWhile in interface PersistentCollectionX<T>
 
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - cycleUntil
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - zip
```
default  PStackX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.util.stream.Stream<? extends U> other)
```
 Description copied from interface: Traversable
 Zip 2 streams into one
```
 {
 @code
 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
 // [[1,"a"],[2,"b"]]
 }
 
```
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface PersistentCollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - zip
```
default  PStackX<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 Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Seq to combine with
 
 Returns:
 
 Combined Zippable
 - zip3
```
default <S,U> PStackX<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second,
 java.util.stream.Stream<? extends U> third)
```
 Description copied from interface: Traversable
 zip 3 Streams into one
```
 {
 @code
 List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(Collectors.toList());
 
 // [[1,100,'a'],[2,200,'b'],[3,300,'c']]
 }
 
 
```
 Specified by:
 
 zip3 in interface CollectionX<T>
 
 Specified by:
 
 zip3 in interface PersistentCollectionX<T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 - zip4
```
default <T2,T3,T4> PStackX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<? extends T2> second,
 java.util.stream.Stream<? extends T3> third,
 java.util.stream.Stream<? extends T4> fourth)
```
 Description copied from interface: Traversable
 zip 4 Streams into 1
```
 {
 @code
 List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
 .collect(Collectors.toList());
 
 }
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 
```
 Specified by:
 
 zip4 in interface CollectionX<T>
 
 Specified by:
 
 zip4 in interface PersistentCollectionX<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 - zipWithIndex
```
default PStackX<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 Traversable<T>
 - distinct
```
default PStackX<T> distinct()
```
 Specified by:
 
 distinct in interface CollectionX<T>
 
 Specified by:
 
 distinct in interface PersistentCollectionX<T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 - sorted
```
default PStackX<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 Traversable<T>
 - sorted
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 c - Compartor to sort with
 
 Returns:
 
 Sorted Stream
 - skipWhile
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 p - Predicate to skip while true
 
 Returns:
 
 Stream with elements skipped while predicate holds
 - skipUntil
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 p - Predicate to skip until true
 
 Returns:
 
 Stream with elements skipped until predicate holds
 - limitWhile
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 p - Limit while predicate is true
 
 Returns:
 
 Stream with limited elements
 - limitUntil
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 p - Limit until predicate is true
 
 Returns:
 
 Stream with limited elements
 - intersperse
```
default PStackX<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 Traversable<T>
 - shuffle
```
default PStackX<T> shuffle()
```
 Specified by:
 
 shuffle in interface CollectionX<T>
 
 Specified by:
 
 shuffle in interface PersistentCollectionX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - skipLast
```
default PStackX<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 Traversable<T>
 
 Returns:
 - limitLast
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 num - of elements to return (last elements)
 
 Returns:
 
 SequenceM limited to last num elements
 - onEmptySwitch
```
default PStackX<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 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
 - onEmpty
```
default PStackX<T> onEmpty(T value)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is empty, create a new instance containing the provided value
 
 Specified by:
 
 onEmpty in interface CollectionX<T>
 
 Specified by:
 
 onEmpty in interface OnEmpty<T>
 
 Specified by:
 
 onEmpty in interface PersistentCollectionX<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 
 Returns:
 
 New instance containing value if container is empty, otherwise returns this container
 - onEmptyGet
```
default PStackX<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is empty, create a new instance containing the value returned from the provided Supplier
 
 Specified by:
 
 onEmptyGet in interface CollectionX<T>
 
 Specified by:
 
 onEmptyGet in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyGet in interface PersistentCollectionX<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 
 Parameters:
 
 supplier - to determine new value for container
 
 Returns:
 
 New Container with value if this is empty, otherwise this container
 - onEmptyThrow
```
default <X extends java.lang.Throwable> PStackX<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
 Description copied from interface: OnEmpty
 
 If this container instance is empty, throw the exception returned by the provided Supplier
 
 Specified by:
 
 onEmptyThrow in interface CollectionX<T>
 
 Specified by:
 
 onEmptyThrow in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyThrow in interface PersistentCollectionX<T>
 
 Specified by:
 
 onEmptyThrow in interface Traversable<T>
 
 Parameters:
 
 supplier - to create exception from
 
 Returns:
 
 Throw exception if empty, otherwise this container
 - shuffle
```
default PStackX<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 Traversable<T>
 - ofType
```
default  PStackX ofType(java.lang.Class<? extends U> type)
```
 Description copied from interface: Filterable
 Keep only those elements in a stream that are of a given type.
```
 
 
 // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
 
 
```
 Specified by:
 
 ofType in interface Filterable<T>
 
 Specified by:
 
 ofType in interface PersistentCollectionX<T>
 - filterNot
```
default PStackX<T> filterNot(java.util.function.Predicate<? super T> fn)
```
 Description copied from interface: Filterable
 Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
 
 
 of(1,2,3).filter(i->i>2);
 
 //[1,2]
 
 
 
```
 Specified by:
 
 filterNot in interface CollectionX<T>
 
 Specified by:
 
 filterNot in interface Filterable<T>
 
 Specified by:
 
 filterNot in interface PersistentCollectionX<T>
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - notNull
```
default PStackX<T> notNull()
```
 Description copied from interface: Filterable
 Filter elements retaining only values which are not null
```
 
 
 of(1,2,null,4).nonNull();
 
 //[1,2,4]
 
 
```
 Specified by:
 
 notNull in interface CollectionX<T>
 
 Specified by:
 
 notNull in interface Filterable<T>
 
 Specified by:
 
 notNull in interface PersistentCollectionX<T>
 
 Returns:
 
 Filterable with nulls removed
 - removeAll
```
default PStackX<T> removeAll(java.util.stream.Stream<? extends T> stream)
```
 Description copied from interface: IterableFilterable
 
 Remove all elements in the supplied Stream from this filterable
 
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Specified by:
 
 removeAll in interface PersistentCollectionX<T>
 
 Parameters:
 
 stream - of elements to remove
 
 Returns:
 
 Filterable with all supplied elements removed
 - removeAll
```
default PStackX<T> removeAll(java.lang.Iterable<? extends T> it)
```
 Description copied from interface: IterableFilterable
 
 Remove all elements in the supplied Iterable from this filterable
 
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Specified by:
 
 removeAll in interface PersistentCollectionX<T>
 
 Parameters:
 
 it - an Iterable of elements to remove
 
 Returns:
 
 Filterable with all supplied elements removed
 - removeAll
```
default PStackX<T> removeAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Remove all supplied elements from this filterable
 
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Specified by:
 
 removeAll in interface PersistentCollectionX<T>
 
 Parameters:
 
 values - to remove
 
 Returns:
 
 Filterable with all supplied values removed
 - retainAll
```
default PStackX<T> retainAll(java.lang.Iterable<? extends T> it)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filterable
 
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Specified by:
 
 retainAll in interface PersistentCollectionX<T>
 
 Parameters:
 
 it - Iterable of elements to retain
 
 Returns:
 
 Filterable with supplied values retained, and others removed
 - retainAll
```
default PStackX<T> retainAll(java.util.stream.Stream<? extends T> seq)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filterable
 
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Specified by:
 
 retainAll in interface PersistentCollectionX<T>
 
 Parameters:
 
 seq - of elements to retain
 
 Returns:
 
 Filterable with supplied values retained, and others removed
 - retainAll
```
default PStackX<T> retainAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filterable
 
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Specified by:
 
 retainAll in interface PersistentCollectionX<T>
 
 Parameters:
 
 values - elements to retain
 
 Returns:
 
 Filterable with supplied values retained, and others removed
 - cast
```
default  PStackX cast(java.lang.Class<? extends U> type)
```
 Description copied from interface: Functor
 
 Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)
 
 Specified by:
 
 cast in interface CollectionX<T>
 
 Specified by:
 
 cast in interface Functor<T>
 
 Specified by:
 
 cast in interface PersistentCollectionX<T>
 - patternMatch
```
default <R> PStackX<R> patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1,
 java.util.function.Supplier<? extends R> otherwise)
```
 Description copied from interface: Functor
 Transform the elements of this Stream with a Pattern Matching case and default value
```
 
 List<String> result = CollectionX.of(1,2,3,4)
 .patternMatch(
 c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
 )
 
 // CollectionX["odd","even","odd","even"]
 
```
 Specified by:
 
 patternMatch in interface CollectionX<T>
 
 Specified by:
 
 patternMatch in interface Functor<T>
 
 Specified by:
 
 patternMatch in interface PersistentCollectionX<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
 - grouped
```
default <C extends java.util.Collection<? super T>> PStackX<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 Traversable<T>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 SequenceM batched into collection types by size
 - groupedUntil
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedStatefullyUntil
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 Traversable windowed while predicate holds
 - groupedWhile
```
default PStackX<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 Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedWhile
```
default <C extends java.util.Collection<? super T>> PStackX<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 Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - groupedUntil
```
default <C extends java.util.Collection<? super T>> PStackX<C> groupedUntil(java.util.function.Predicate<? super T> predicate,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: Traversable
 Create a SequenceM batched by a Collection, where each batch is populated until the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .batchUntil(i->i%3!=0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedUntil in interface CollectionX<T>
 
 Specified by:
 
 groupedUntil in interface PersistentCollectionX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - removeAll
```
default PStackX<T> removeAll(org.jooq.lambda.Seq<? extends T> stream)
```
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Specified by:
 
 removeAll in interface PersistentCollectionX<T>
 
 Returns:
 - retainAll
```
default PStackX<T> retainAll(org.jooq.lambda.Seq<? extends T> stream)
```
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface PersistentCollectionX<T>
 
 Returns:

Interface PStackX<T>

Method Summary

Methods inherited from interface org.pcollections.PStack

Methods inherited from interface org.pcollections.PSequence

Methods inherited from interface org.pcollections.PCollection

Methods inherited from interface java.util.List

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

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

Methods inherited from interface org.jooq.lambda.Collectable

Method Detail

range

rangeLong

unfold

generate

iterate

of

fromPublisher

fromIterable

fromCollection

empty

singleton

fromStream

toPStackX

combine

unit

unit

unitIterator

emptyUnit

toPStack

plusInOrder

stream

from

monoid

reverse

efficientOpsOn

efficientOpsOff

isEfficientOps

filter

map

flatMap

limit

skip

takeRight

dropRight

takeWhile

dropWhile

takeUntil

dropUntil

trampoline

slice

sorted

minusAll

minus

with

plus

plus

plusAll

plusAll

minus

subList

grouped

grouped

grouped

zip

zip

zip

zip

permutations

combinations

combinations

sliding

sliding

scanLeft

scanRight

scanLeft