public interface PStackX<T> extends To<PStackX<T>>, org.pcollections.PStack<T>, PersistentCollectionX<T>, FluentSequenceX<T>, OnEmptySwitch<T,org.pcollections.PStack<T>>, Higher<PStackX.µ,T>
Modifier and Type | Interface and Description |
---|---|
static class |
PStackX.µ |
static class |
PStackX.Instances
Companion class for creating Type Class instances for working with PStacks
|
Fn1.FunctionalOperations<T1,R>
Modifier and Type | Method and Description |
---|---|
default PStackX<T> |
append(T... values)
Append values to the take of this ReactiveSeq
|
default PStackX<T> |
append(T value) |
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 <R> PStackX<R> |
coflatMap(java.util.function.Function<? super PStackX<T>,? extends R> fn)
coflatMap pattern, can be used to perform lazy reductions / collections / folds and other terminal operations
|
default PStackX<ReactiveSeq<T>> |
combinations()
Generate the combinations based on values in the ExtendedTraversable.
|
default PStackX<ReactiveSeq<T>> |
combinations(int size)
Generate the combinations based on values in the ExtendedTraversable.
|
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(long times)
Convert to a Stream with the values repeated specified times
|
default PStackX<T> |
cycle(Monoid<T> m,
long 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> |
deleteBetween(int start,
int end)
Delete elements between given indexes in a Stream
|
default PStackX<T> |
distinct() |
default PStackX<T> |
drop(long num)
assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7))); |
default PStackX<T> |
dropRight(int num)
Generate a new Traversable that drops the specified number elements from the take of this Traversable
|
default PStackX<T> |
dropUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that drops elements from this Traversable until the predicate holds
|
default PStackX<T> |
dropWhile(java.util.function.Predicate<? super T> p)
Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
|
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() |
static <T> PStackX<T> |
fill(long limit,
T s)
Generate a PStackX from the provided value up to the provided limit number of times
|
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)
Perform a flatMap operation on this collection.
|
default <R> PStackX<R> |
flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn) |
default <R> PStackX<R> |
flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn) |
default <R1,R> PStackX<R> |
forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
Perform a two level nested internal iteration over this Stream and the
supplied stream
|
default <R1,R> PStackX<R> |
forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
Perform a two level nested internal iteration over this Stream and the
supplied stream
|
default <R1,R2,R> PStackX<R> |
forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2,
Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the
supplied streams
|
default <R1,R2,R> PStackX<R> |
forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2,
Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the
supplied streams
|
default <R1,R2,R3,R> |
forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2,
Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> stream3,
Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the
supplied streams
|
default <R1,R2,R3,R> |
forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2,
Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> stream3,
Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the
supplied streams
|
default <X> PStackX<X> |
from(java.util.Collection<X> col)
Conctruct an Extended Collection from a standard Collection
|
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> |
fromIterator(java.util.Iterator<T> it)
Construct a PStackX from the provided Iterator
|
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,ReactiveSeq<T>>> |
grouped(java.util.function.Function<? super T,? extends K> classifier)
Group this Traversable by the provided classifying function and collected by the provided Collector
|
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)
Group this Traversable by the provided classifying function and collected by the provided Collector
|
default PStackX<ListX<T>> |
grouped(int groupSize)
Group elements in a Stream
|
default <C extends java.util.Collection<? super T>> |
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>> |
groupedUntil(java.util.function.Predicate<? super T> predicate,
java.util.function.Supplier<C> factory)
Create a ReactiveSeq batched by a Collection, where each batch is populated
until the predicate holds
|
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>> |
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> |
insertAt(int pos,
T... values)
Insert data into a stream at given position
|
default PStackX<T> |
insertAtS(int pos,
java.util.stream.Stream<T> stream)
Insert a Stream into the middle of this stream at the specified position
|
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 <W extends WitnessType<W>> |
liftM(W witness) |
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
|
default PStackX<T> |
materialize() |
PStackX<T> |
minus(int i)
Remove the element at the supplied index
|
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() |
static <T> PStackX<T> |
narrow(PStackX<? extends T> stackX)
Narrow a covariant PStackX
|
static <T> PStackX<T> |
narrowK(Higher<PStackX.µ,T> list)
Convert the raw Higher Kinded Type for PStack types into the PStackType type definition class
|
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> |
onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
If this container instance is empty, throw the exception returned by the provided Supplier
|
default PStackX<ReactiveSeq<T>> |
permutations()
Generate the permutations based on values in the ExtendedTraversable.
|
PStackX<T> |
plus(int i,
T e)
Add the supplied element at the supplied index
|
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)
Add all of the supplied elements at the supplied index
|
default PStackX<T> |
plusInOrder(T e)
Add an element to the collection
|
default PStackX<T> |
plusLoop(int max,
java.util.function.IntFunction<T> value) |
default PStackX<T> |
plusLoop(java.util.function.Supplier<java.util.Optional<T>> supplier) |
default PStackX<T> |
prepend(T... values)
Prepend given values to the skip of the Stream
|
default PStackX<T> |
prepend(T value) |
default PStackX<T> |
prependS(java.util.stream.Stream<? extends T> stream)
Prepend Stream to this ReactiveSeq
|
static PStackX<java.lang.Integer> |
range(int start,
int end)
Create a PStackX that contains the Integers between skip and take
|
static PStackX<java.lang.Long> |
rangeLong(long start,
long end)
Create a PStackX that contains the Longs between skip and take
|
default <EX extends java.lang.Throwable> |
recover(java.lang.Class<EX> exceptionClass,
java.util.function.Function<? super EX,? extends T> fn)
Recover from a particular exception type
|
default PStackX<T> |
recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)
Recover from an exception with an alternative value
|
default PStackX<T> |
removeAllS(java.lang.Iterable<? extends T> it)
Remove all elements in the supplied Iterable from this filterable
|
default PStackX<T> |
removeAllS(java.util.stream.Stream<? extends T> stream)
Remove all elements in the supplied Stream from this filterable
|
default PStackX<T> |
removeAllS(T... values)
Remove all supplied elements from this filterable
|
default PStackX<T> |
retainAllS(java.lang.Iterable<? extends T> it)
Retain only the supplied elements in the returned Filters
|
default PStackX<T> |
retainAllS(java.util.stream.Stream<? extends T> seq)
Retain only the supplied elements in the returned Filters
|
default PStackX<T> |
retainAllS(T... values)
Retain only the supplied elements in the returned Filters
|
default <R> PStackX<R> |
retry(java.util.function.Function<? super T,? extends R> fn)
Retry a transformation if it fails.
|
default <R> PStackX<R> |
retry(java.util.function.Function<? super T,? extends R> fn,
int retries,
long delay,
java.util.concurrent.TimeUnit timeUnit)
Retry a transformation if it fails.
|
default PStackX<T> |
reverse()
Potentially efficient Stream reversal.
|
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<PVectorX<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
default PStackX<PVectorX<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>> |
sorted(java.util.function.Function<? super T,? extends U> function) |
default ReactiveSeq<T> |
stream() |
PStackX<T> |
subList(int start,
int end)
Create a sub sequence between the two supplied index
|
default PStackX<T> |
take(long num)
assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3)); |
default PStackX<T> |
takeRight(int num)
Generate a new Traversable that takes the specified number elements from the take of this Traversable
|
default PStackX<T> |
takeUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that takes elements from this Traversable until the predicate holds
|
default PStackX<T> |
takeWhile(java.util.function.Predicate<? super T> p)
Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
|
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
|
static <C2,T> Higher<C2,Higher<PStackX.µ,T>> |
widen2(Higher<C2,PStackX<T>> list)
Widen a PStackType nested inside another HKT encoded type
|
PStackX<T> |
with(int i,
T e)
Replace the value at the specifed index with the supplied value
|
default <U> PStackX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.lang.Iterable<? extends U> other)
Zip (merge) this collection with the supplied Iterable into a Colleciton containing Tuples
Each Tuple contains one element from this collection and one from the other
|
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 <S,U> PStackX<org.jooq.lambda.tuple.Tuple3<T,S,U>> |
zip3(java.lang.Iterable<? extends S> second,
java.lang.Iterable<? extends U> third)
zip 3 Streams into one
|
default <T2,T3,T4> PStackX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> |
zip4(java.lang.Iterable<? extends T2> second,
java.lang.Iterable<? extends T3> third,
java.lang.Iterable<? extends T4> fourth)
zip 4 Streams into 1
|
default <U> PStackX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zipS(java.util.stream.Stream<? extends U> other)
Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
|
default <U,R> PStackX<R> |
zipS(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 PStackX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
add, addAll, clear, remove, removeAll, retainAll
add, addAll, clear, contains, containsAll, equals, get, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, remove, removeAll, replaceAll, retainAll, size, sort, spliterator, toArray, toArray
findAny, findFirst, getAtIndex, groupBy, head, headAndTail, isEmpty, iterator, peek, single, single, singleOptional
apply, foldFuture, foldLazy, foldTry, forEach, forEach, forEach, forEach, forEach, runFuture, runLazy, seq, visit
andThen, andThen, bind, compose, functionOps, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, product, reader, λ, λv
apply, applyPartially, applyPartially, curry, curry, from, toFunction
allMatch, anyMatch, avg, avgDouble, avgInt, avgLong, bitAnd, bitAndInt, bitAndLong, bitOr, bitOrInt, bitOrLong, collect, collectable, 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, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toMap, toSet, toSet, toString, toString
endsWith, endsWithIterable, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, xMatch
toDequeX, toFutureStream, toFutureStream, toListX, toMapX, toOptional, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toValue
static <C2,T> Higher<C2,Higher<PStackX.µ,T>> widen2(Higher<C2,PStackX<T>> list)
list
- HTK encoded type containing a PStack to widenstatic <T> PStackX<T> narrowK(Higher<PStackX.µ,T> list)
list
- HKT encoded list into a PStackTypedefault <W extends WitnessType<W>> ListT<W,T> liftM(W witness)
static <T> PStackX<T> narrow(PStackX<? extends T> stackX)
PStackX<? extends Fruit> set = PStackX.of(apple,bannana);
PStackX<Fruit> fruitSet = PStackX.narrow(set);
stackX
- to narrow generic typestatic PStackX<java.lang.Integer> range(int start, int end)
start
- Number of range to skip fromend
- Number for range to take atstatic PStackX<java.lang.Long> rangeLong(long start, long end)
start
- Number of range to skip fromend
- Number for range to take atstatic <U,T> PStackX<T> unfold(U seed, java.util.function.Function<? super U,java.util.Optional<org.jooq.lambda.tuple.Tuple2<T,U>>> unfolder)
PStackX.unfold(1,i->i<=6 ? Optional.of(Tuple.tuple(i,i+1)) : Optional.empty());
//(1,2,3,4,5)
seed
- Initial valueunfolder
- Iteratively applied function, terminated by an empty Optionalstatic <T> PStackX<T> generate(long limit, java.util.function.Supplier<T> s)
limit
- Max number of elements to generates
- Supplier to generate PStackX elementsstatic <T> PStackX<T> fill(long limit, T s)
limit
- Max number of elements to generates
- Value for PStackX elementsstatic <T> PStackX<T> iterate(long limit, T seed, java.util.function.UnaryOperator<T> f)
limit
- Max number of elements to generateseed
- Initial elementf
- Iteratively applied to each element to generate the next element@SafeVarargs static <T> PStackX<T> of(T... values)
List<String> list = PStacks.of("a","b","c");
// or
PStack<String> list = PStacks.of("a","b","c");
values
- To add to PStackstatic <T> PStackX<T> fromIterator(java.util.Iterator<T> it)
it
- Iterator to populate PStackXstatic <T> PStackX<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
publisher
- to construct PStackX fromstatic <T> PStackX<T> fromIterable(java.lang.Iterable<T> iterable)
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"));
fromCollection
in interface CollectionX<T>
values
- To add to PStackstatic <T> PStackX<T> empty()
List<String> empty = PStack.empty();
//or
PStack<String> empty = PStack.empty();
static <T> PStackX<T> singleton(T value)
List<String> single = PStacks.singleton("1");
//or
PStack<String> single = PStacks.singleton("1");
value
- Single value for PVectorstatic <T> PStackX<T> fromStream(java.util.stream.Stream<T> stream)
PStack<Integer> list = PStacks.fromStream(Stream.of(1,2,3));
//list = [3,2,1]
stream
- to convert to a PVectordefault PStackX<T> materialize()
materialize
in interface CollectionX<T>
default <R1,R2,R3,R> PStackX<R> forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2, Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> stream3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
CollectionX
//collectionX [1,2]
collectionX.forEach4(a->ListX.range(10,13),
(a,b)->ListX.of(""+(a+b),"hello world"),
(a,b,c)->ListX.of(a,b,c)),
(a,b,c,d)->c+":"a+":"+b);
forEach4
in interface CollectionX<T>
stream1
- Nested Stream to iterate overstream2
- Nested Stream to iterate overstream3
- Nested Stream to iterate overyieldingFunction
- Function with pointers to the current element from both
Streams that generates the new elementsdefault <R1,R2,R3,R> PStackX<R> forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2, Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> stream3, Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
CollectionX
//collectionX [1,2,3]
collectionX.forEach4(a->ListX.range(10,13),
(a,b)->ListX.of(""+(a+b),"hello world"),
(a,b,c)->ListX.of(a,b,c),
(a,b,c,d)-> c!=3,
(a,b,c)->c+":"a+":"+b);
forEach4
in interface CollectionX<T>
stream1
- Nested Stream to iterate overstream2
- Nested Stream to iterate overstream3
- Nested Stream to iterate overfilterFunction
- Filter to apply over elements before passing non-filtered
values to the yielding functionyieldingFunction
- Function with pointers to the current element from both
Streams that generates the new elementsdefault <R1,R2,R> PStackX<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
CollectionX
//collectionX [1,2]
collectionX.forEach3(a->IntStream.range(10,13),
(a,b)->Stream.of(""+(a+b),"hello world"),
(a,b,c)->c+":"a+":"+b);
//CollectionX[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
forEach3
in interface CollectionX<T>
stream1
- Nested Stream to iterate overstream2
- Nested Stream to iterate overyieldingFunction
- Function with pointers to the current element from both
Streams that generates the new elementsdefault <R1,R2,R> PStackX<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2, Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
CollectionX
//collectionX [1,2,3]
collectionX.forEach3(a->ListX.range(10,13),
(a,b)->Stream.of(""+(a+b),"hello world"),
(a,b,c)-> c!=3,
(a,b,c)->c+":"a+":"+b);
//CollectionX[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
forEach3
in interface CollectionX<T>
stream1
- Nested Stream to iterate overstream2
- Nested Stream to iterate overfilterFunction
- Filter to apply over elements before passing non-filtered
values to the yielding functionyieldingFunction
- Function with pointers to the current element from both
Streams that generates the new elementsdefault <R1,R> PStackX<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
CollectionX
//collectionX [1,2,3]
collectionX.of(1,2,3).forEach2(a->ListX.range(10,13),
(a,b)->a+b);
//ReactiveSeq[11,14,12,15,13,16]
forEach2
in interface CollectionX<T>
stream1
- Nested Iterable to iterate overyieldingFunction
- Function with pointers to the current element from both
Streams that generates the new elementsdefault <R1,R> PStackX<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
CollectionX
//collectionX [1,2,3]
collectionX.of(1,2,3).forEach2(a->ListX.range(10,13),
(a,b)-> a<3 && b>10,
(a,b)->a+b);
//CollectionX[14,15]
forEach2
in interface CollectionX<T>
stream1
- Nested Stream to iterate overfilterFunction
- Filter to apply over elements before passing non-filtered
values to the yielding functionyieldingFunction
- Function with pointers to the current element from both
Streams that generates the new elementsdefault PStackX<T> take(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));
take
in interface CollectionX<T>
take
in interface Traversable<T>
num
- Limit element size to numdefault PStackX<T> drop(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));
drop
in interface CollectionX<T>
drop
in interface Traversable<T>
num
- Number of elemenets to dropdefault PStackX<T> toPStackX()
toPStackX
in interface ConvertableSequence<T>
default <R> PStackX<R> coflatMap(java.util.function.Function<? super PStackX<T>,? extends R> fn)
PStackX.of(1,2,3)
.map(i->i*2)
.coflatMap(s -> s.reduce(0,(a,b)->a+b))
//PStackX[12]
fn
- mapping functiondefault PStackX<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)
PStackX.of(1,1,2,3)
.combine((a, b)->a.equals(b),Semigroups.intSum)
.toListX()
//ListX(3,4)
combine
in interface CollectionX<T>
combine
in interface PersistentCollectionX<T>
combine
in interface Traversable<T>
predicate
- Test to see if two neighbors should be joinedop
- Reducer to combine neighborsdefault <R> PStackX<R> unit(java.util.Collection<R> col)
FluentCollectionX
unit
in interface FluentCollectionX<T>
unit
in interface PersistentCollectionX<T>
col
- Collection data to populate the new collectiondefault <R> PStackX<R> unit(R value)
unit
in interface CollectionX<T>
default <R> PStackX<R> unitIterator(java.util.Iterator<R> it)
Traversable
ReactiveSeq<Integer> newSeq = seq.unitIterable(myIterator);
unitIterator
in interface Traversable<T>
it
- Iterator to create new IterableFunctor fromdefault <R> PStackX<R> emptyUnit()
emptyUnit
in interface PersistentCollectionX<T>
default org.pcollections.PStack<T> toPStack()
default PStackX<T> plusInOrder(T e)
FluentCollectionX
plusInOrder
in interface FluentCollectionX<T>
plusInOrder
in interface PersistentCollectionX<T>
e
- Element to adddefault ReactiveSeq<T> stream()
stream
in interface java.util.Collection<T>
stream
in interface CollectionX<T>
stream
in interface ConvertableSequence<T>
stream
in interface ExtendedTraversable<T>
stream
in interface FoldableTraversable<T>
stream
in interface PersistentCollectionX<T>
stream
in interface Sequential<T>
stream
in interface ToStream<T>
stream
in interface TransformerTraversable<T>
stream
in interface Traversable<T>
default <X> PStackX<X> from(java.util.Collection<X> col)
CollectionX
from
in interface CollectionX<T>
from
in interface PersistentCollectionX<T>
col
- Collection to extenddefault <T> Reducer<org.pcollections.PStack<T>> monoid()
monoid
in interface PersistentCollectionX<T>
default PStackX<T> reverse()
Traversable
assertThat( of(1, 2, 3).reverse().toList(),
equalTo(asList(3, 2, 1)));
reverse
in interface CollectionX<T>
reverse
in interface PersistentCollectionX<T>
reverse
in interface Traversable<T>
boolean isEfficientOps()
default PStackX<T> filter(java.util.function.Predicate<? super T> pred)
Filters
of(1,2,3).filter(i->i>2);
//[3]
filter
in interface CollectionX<T>
filter
in interface FilterableTransformable<T>
filter
in interface Filters<T>
filter
in interface FluentSequenceX<T>
filter
in interface PersistentCollectionX<T>
pred
- to filter elements by, retaining matchesdefault <R> PStackX<R> map(java.util.function.Function<? super T,? extends R> mapper)
Transformable
of(1,2,3).map(i->i*2)
//[2,4,6]
map
in interface CollectionX<T>
map
in interface FilterableTransformable<T>
map
in interface FluentSequenceX<T>
map
in interface PersistentCollectionX<T>
map
in interface Transformable<T>
mapper
- Transformation functiondefault <R> PStackX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
CollectionX
flatMap
in interface CollectionX<T>
flatMap
in interface FluentSequenceX<T>
flatMap
in interface PersistentCollectionX<T>
mapper
- Transformation function to be applied (and flattened)default PStackX<T> limit(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
limit
in interface CollectionX<T>
limit
in interface PersistentCollectionX<T>
limit
in interface Traversable<T>
num
- Limit element size to numdefault PStackX<T> skip(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));
skip
in interface CollectionX<T>
skip
in interface PersistentCollectionX<T>
skip
in interface Traversable<T>
num
- Number of elemenets to skipdefault PStackX<T> takeRight(int num)
Traversable
ListX.of(1,2,3).takeRight(2);
//[2,3]
takeRight
in interface CollectionX<T>
takeRight
in interface PersistentCollectionX<T>
takeRight
in interface Traversable<T>
num
- Take this number of elements from the take of this Traversabledefault PStackX<T> dropRight(int num)
Traversable
ListX.of(1,2,3).dropRight(2);
//[1]
dropRight
in interface CollectionX<T>
dropRight
in interface PersistentCollectionX<T>
dropRight
in interface Traversable<T>
num
- Drop this number of elements from the take of this Traversabledefault PStackX<T> takeWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeWhile(i<3);
//[1,2]
takeWhile
in interface CollectionX<T>
takeWhile
in interface PersistentCollectionX<T>
takeWhile
in interface Traversable<T>
p
- Predicate to determine when values should be takendefault PStackX<T> dropWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropWhile(i<3);
//[3]
dropWhile
in interface CollectionX<T>
dropWhile
in interface PersistentCollectionX<T>
dropWhile
in interface Traversable<T>
p
- Predicate to determine when values should be droppeddefault PStackX<T> takeUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeUntil(i<2);
//[1,2]
takeUntil
in interface CollectionX<T>
takeUntil
in interface PersistentCollectionX<T>
takeUntil
in interface Traversable<T>
p
- Predicate to determine when values should be taken untildefault PStackX<T> dropUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropUntil(i>2);
//[3]
dropUntil
in interface CollectionX<T>
dropUntil
in interface PersistentCollectionX<T>
dropUntil
in interface Traversable<T>
p
- Predicate to determine when values should be droppeddefault <R> PStackX<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
PersistentCollectionX
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
trampoline
in interface CollectionX<T>
trampoline
in interface PersistentCollectionX<T>
trampoline
in interface Transformable<T>
mapper
- TCO Transformation functiondefault PStackX<T> slice(long from, long to)
slice
in interface CollectionX<T>
slice
in interface PersistentCollectionX<T>
slice
in interface Traversable<T>
default <U extends java.lang.Comparable<? super U>> PStackX<T> sorted(java.util.function.Function<? super T,? extends U> function)
sorted
in interface CollectionX<T>
sorted
in interface PersistentCollectionX<T>
sorted
in interface Traversable<T>
PStackX<T> minusAll(java.util.Collection<?> list)
FluentCollectionX
minusAll
in interface FluentCollectionX<T>
minusAll
in interface FluentSequenceX<T>
minusAll
in interface org.pcollections.PCollection<T>
minusAll
in interface org.pcollections.PSequence<T>
minusAll
in interface org.pcollections.PStack<T>
list
- of elements to removePStackX<T> minus(java.lang.Object remove)
FluentCollectionX
minus
in interface FluentCollectionX<T>
minus
in interface FluentSequenceX<T>
minus
in interface org.pcollections.PCollection<T>
minus
in interface org.pcollections.PSequence<T>
minus
in interface org.pcollections.PStack<T>
remove
- Element to removePStackX<T> with(int i, T e)
FluentSequenceX
with
in interface FluentSequenceX<T>
with
in interface org.pcollections.PSequence<T>
with
in interface org.pcollections.PStack<T>
i
- e
- PStack.with(int, java.lang.Object)
PStackX<T> plus(int i, T e)
FluentSequenceX
plus
in interface FluentSequenceX<T>
plus
in interface org.pcollections.PSequence<T>
plus
in interface org.pcollections.PStack<T>
i
- e
- PStack.plus(int, java.lang.Object)
PStackX<T> plus(T e)
FluentCollectionX
plus
in interface FluentCollectionX<T>
plus
in interface FluentSequenceX<T>
plus
in interface org.pcollections.PCollection<T>
plus
in interface org.pcollections.PSequence<T>
plus
in interface org.pcollections.PStack<T>
e
- Element to addPStackX<T> plusAll(java.util.Collection<? extends T> list)
FluentCollectionX
plusAll
in interface FluentCollectionX<T>
plusAll
in interface FluentSequenceX<T>
plusAll
in interface org.pcollections.PCollection<T>
plusAll
in interface org.pcollections.PSequence<T>
plusAll
in interface org.pcollections.PStack<T>
list
- of elements to addPStackX<T> plusAll(int i, java.util.Collection<? extends T> list)
FluentSequenceX
plusAll
in interface FluentSequenceX<T>
plusAll
in interface org.pcollections.PSequence<T>
plusAll
in interface org.pcollections.PStack<T>
i
- list
- PStack.plusAll(int, java.util.Collection)
PStackX<T> minus(int i)
FluentSequenceX
minus
in interface FluentSequenceX<T>
minus
in interface org.pcollections.PSequence<T>
minus
in interface org.pcollections.PStack<T>
i
- PStack.minus(int)
PStackX<T> subList(int start, int end)
FluentSequenceX
subList
in interface FluentSequenceX<T>
subList
in interface java.util.List<T>
subList
in interface org.pcollections.PSequence<T>
subList
in interface org.pcollections.PStack<T>
start
- Index of our sub sequence (inclusive)end
- Index of our sub sequence (exclusive)default PStackX<ListX<T>> grouped(int groupSize)
Traversable
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));
grouped
in interface CollectionX<T>
grouped
in interface PersistentCollectionX<T>
grouped
in interface Traversable<T>
groupSize
- Size of each Groupdefault <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)
Traversable
grouped
in interface CollectionX<T>
grouped
in interface PersistentCollectionX<T>
grouped
in interface Traversable<T>
classifier
- Grouping functiondownstream
- Collector to create the grouping collectiondefault <K> PStackX<org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
Traversable
grouped
in interface CollectionX<T>
grouped
in interface PersistentCollectionX<T>
grouped
in interface Traversable<T>
classifier
- Grouping functiondefault <U> PStackX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
CollectionX
zip
in interface CollectionX<T>
zip
in interface PersistentCollectionX<T>
zip
in interface Zippable<T>
other
- Collection to merge with this onedefault <U,R> PStackX<R> zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
zip
in interface CollectionX<T>
zip
in interface PersistentCollectionX<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- to zip withzipper
- Zip functiondefault <U,R> PStackX<R> zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
zipS
in interface CollectionX<T>
zipS
in interface PersistentCollectionX<T>
zipS
in interface Zippable<T>
other
- Stream to combine withzipper
- Zip / combining functiondefault PStackX<ReactiveSeq<T>> permutations()
ExtendedTraversable
permutations
in interface CollectionX<T>
permutations
in interface ExtendedTraversable<T>
permutations
in interface PersistentCollectionX<T>
default PStackX<ReactiveSeq<T>> combinations(int size)
ExtendedTraversable
ExtendedTraversable<Integer> stream = ReactiveSeq.of(1,2,3);
stream.combinations(2)
//ReactiveSeq[ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]]
combinations
in interface CollectionX<T>
combinations
in interface ExtendedTraversable<T>
combinations
in interface PersistentCollectionX<T>
size
- of combinationsdefault PStackX<ReactiveSeq<T>> combinations()
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]]
combinations
in interface CollectionX<T>
combinations
in interface ExtendedTraversable<T>
combinations
in interface PersistentCollectionX<T>
default PStackX<PVectorX<T>> sliding(int windowSize)
Traversable
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));
sliding
in interface CollectionX<T>
sliding
in interface PersistentCollectionX<T>
sliding
in interface Traversable<T>
windowSize
- Size of sliding windowdefault PStackX<PVectorX<T>> sliding(int windowSize, int increment)
Traversable
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));
sliding
in interface CollectionX<T>
sliding
in interface PersistentCollectionX<T>
sliding
in interface Traversable<T>
windowSize
- number of elements in each batchincrement
- for each windowdefault <U> PStackX<U> scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)
Traversable
assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
is(4));
scanLeft
in interface CollectionX<T>
scanLeft
in interface PersistentCollectionX<T>
scanLeft
in interface Traversable<T>
default <U> PStackX<U> scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Traversable
assertThat(of("a", "ab", "abc").map(str->str.length()).scanRight(0, (t, u) -> u + t).toList().size(),
is(asList(0, 3, 5, 6).size()));
scanRight
in interface CollectionX<T>
scanRight
in interface PersistentCollectionX<T>
scanRight
in interface Traversable<T>
default PStackX<T> scanLeft(Monoid<T> monoid)
Traversable
assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
.scanLeft(Reducers.toString("")).toList());
scanLeft
in interface CollectionX<T>
scanLeft
in interface PersistentCollectionX<T>
scanLeft
in interface Traversable<T>
default PStackX<T> scanRight(Monoid<T> monoid)
Traversable
assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
is(asList("", "c", "bc", "abc").size()));
scanRight
in interface CollectionX<T>
scanRight
in interface PersistentCollectionX<T>
scanRight
in interface Traversable<T>
default PStackX<T> cycle(long times)
Traversable
ReactiveSeq.of(1,2,2)
.cycle(3)
.collect(Collectors.toList());
//List[1,2,2,1,2,2,1,2,2]
cycle
in interface CollectionX<T>
cycle
in interface PersistentCollectionX<T>
cycle
in interface Traversable<T>
times
- Times values should be repeated within a Streamdefault PStackX<T> cycle(Monoid<T> m, long times)
Traversable
List<Integer> list = ReactiveSeq.of(1,2,2))
.cycle(Reducers.toCountInt(),3)
.collect(Collectors.toList());
//List[3,3,3];
cycle
in interface CollectionX<T>
cycle
in interface PersistentCollectionX<T>
cycle
in interface Traversable<T>
m
- Monoid to be used in reductiontimes
- Number of times value should be repeateddefault PStackX<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
Traversable
MutableInt count = MutableInt.of(0);
ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6).collect(Collectors.toList());
// List(1,2,2,1,2,2)
cycleWhile
in interface CollectionX<T>
cycleWhile
in interface PersistentCollectionX<T>
cycleWhile
in interface Traversable<T>
predicate
- repeat while truedefault PStackX<T> cycleUntil(java.util.function.Predicate<? super T> predicate)
Traversable
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]
cycleUntil
in interface CollectionX<T>
cycleUntil
in interface PersistentCollectionX<T>
cycleUntil
in interface Traversable<T>
predicate
- repeat while truedefault <U> PStackX<org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)
Traversable
zipS
in interface CollectionX<T>
zipS
in interface PersistentCollectionX<T>
zipS
in interface Traversable<T>
zipS
in interface Zippable<T>
other
- Stream to combine withdefault <S,U> PStackX<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)
Traversable
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']]
zip3
in interface CollectionX<T>
zip3
in interface PersistentCollectionX<T>
zip3
in interface Traversable<T>
zip3
in interface Zippable<T>
default <T2,T3,T4> PStackX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)
Traversable
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"]]
zip4
in interface CollectionX<T>
zip4
in interface PersistentCollectionX<T>
zip4
in interface Traversable<T>
zip4
in interface Zippable<T>
default PStackX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()
Traversable
assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").zipWithIndex().toList());
zipWithIndex
in interface CollectionX<T>
zipWithIndex
in interface PersistentCollectionX<T>
zipWithIndex
in interface Traversable<T>
default PStackX<T> distinct()
distinct
in interface CollectionX<T>
distinct
in interface PersistentCollectionX<T>
distinct
in interface Traversable<T>
default PStackX<T> sorted()
Traversable
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));
sorted
in interface CollectionX<T>
sorted
in interface PersistentCollectionX<T>
sorted
in interface Traversable<T>
default PStackX<T> sorted(java.util.Comparator<? super T> c)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
sorted
in interface CollectionX<T>
sorted
in interface PersistentCollectionX<T>
sorted
in interface Traversable<T>
c
- Compartor to sort withdefault PStackX<T> skipWhile(java.util.function.Predicate<? super T> p)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
skipWhile
in interface CollectionX<T>
skipWhile
in interface PersistentCollectionX<T>
skipWhile
in interface Traversable<T>
p
- Predicate to skip while truedefault PStackX<T> skipUntil(java.util.function.Predicate<? super T> p)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
skipUntil
in interface CollectionX<T>
skipUntil
in interface PersistentCollectionX<T>
skipUntil
in interface Traversable<T>
p
- Predicate to skip until truedefault PStackX<T> limitWhile(java.util.function.Predicate<? super T> p)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
limitWhile
in interface CollectionX<T>
limitWhile
in interface PersistentCollectionX<T>
limitWhile
in interface Traversable<T>
p
- Limit while predicate is truedefault PStackX<T> limitUntil(java.util.function.Predicate<? super T> p)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3)));
limitUntil
in interface CollectionX<T>
limitUntil
in interface PersistentCollectionX<T>
limitUntil
in interface Traversable<T>
p
- Limit until predicate is truedefault PStackX<T> intersperse(T value)
Traversable
intersperse
in interface CollectionX<T>
intersperse
in interface PersistentCollectionX<T>
intersperse
in interface Traversable<T>
default PStackX<T> shuffle()
shuffle
in interface CollectionX<T>
shuffle
in interface PersistentCollectionX<T>
shuffle
in interface Traversable<T>
default PStackX<T> skipLast(int num)
Traversable
skipLast
in interface CollectionX<T>
skipLast
in interface PersistentCollectionX<T>
skipLast
in interface Traversable<T>
default PStackX<T> limitLast(int num)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5)
.limitLast(2)
.collect(Collectors.toList()),equalTo(Arrays.asList(4,5)));
limitLast
in interface CollectionX<T>
limitLast
in interface PersistentCollectionX<T>
limitLast
in interface Traversable<T>
num
- of elements to return (last elements)default PStackX<T> onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PStack<T>> supplier)
OnEmptySwitch
ListX.empty().onEmptySwitch(()->ListX.of(1));
onEmptySwitch
in interface OnEmptySwitch<T,org.pcollections.PStack<T>>
supplier
- to create replacement containerdefault PStackX<T> onEmpty(T value)
OnEmpty
onEmpty
in interface CollectionX<T>
onEmpty
in interface OnEmpty<T>
onEmpty
in interface PersistentCollectionX<T>
onEmpty
in interface Traversable<T>
default PStackX<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
OnEmpty
onEmptyGet
in interface CollectionX<T>
onEmptyGet
in interface OnEmpty<T>
onEmptyGet
in interface PersistentCollectionX<T>
onEmptyGet
in interface Traversable<T>
supplier
- to determine new value for containerdefault <X extends java.lang.Throwable> PStackX<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
OnEmpty
onEmptyThrow
in interface CollectionX<T>
onEmptyThrow
in interface OnEmpty<T>
onEmptyThrow
in interface PersistentCollectionX<T>
onEmptyThrow
in interface Traversable<T>
supplier
- to create exception fromdefault PStackX<T> shuffle(java.util.Random random)
shuffle
in interface CollectionX<T>
shuffle
in interface PersistentCollectionX<T>
shuffle
in interface Traversable<T>
default <U> PStackX<U> ofType(java.lang.Class<? extends U> type)
Filters
// (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
default PStackX<T> filterNot(java.util.function.Predicate<? super T> fn)
Filters
of(1,2,3).filter(i->i>2);
//[1,2]
filterNot
in interface CollectionX<T>
filterNot
in interface Filters<T>
filterNot
in interface PersistentCollectionX<T>
fn
- to filter elements by, retaining matchesdefault PStackX<T> notNull()
Filters
of(1,2,null,4).nonNull();
//[1,2,4]
notNull
in interface CollectionX<T>
notNull
in interface Filters<T>
notNull
in interface PersistentCollectionX<T>
default PStackX<T> removeAllS(java.util.stream.Stream<? extends T> stream)
IterableFilterable
removeAllS
in interface CollectionX<T>
removeAllS
in interface IterableFilterable<T>
removeAllS
in interface PersistentCollectionX<T>
stream
- of elements to removedefault PStackX<T> removeAllS(java.lang.Iterable<? extends T> it)
IterableFilterable
removeAllS
in interface CollectionX<T>
removeAllS
in interface IterableFilterable<T>
removeAllS
in interface PersistentCollectionX<T>
it
- an Iterable of elements to removedefault PStackX<T> removeAllS(T... values)
IterableFilterable
removeAllS
in interface CollectionX<T>
removeAllS
in interface IterableFilterable<T>
removeAllS
in interface PersistentCollectionX<T>
values
- to removedefault PStackX<T> retainAllS(java.lang.Iterable<? extends T> it)
IterableFilterable
retainAllS
in interface CollectionX<T>
retainAllS
in interface IterableFilterable<T>
retainAllS
in interface PersistentCollectionX<T>
it
- Iterable of elements to retaindefault PStackX<T> retainAllS(java.util.stream.Stream<? extends T> seq)
IterableFilterable
retainAllS
in interface CollectionX<T>
retainAllS
in interface IterableFilterable<T>
retainAllS
in interface PersistentCollectionX<T>
seq
- of elements to retaindefault PStackX<T> retainAllS(T... values)
IterableFilterable
retainAllS
in interface CollectionX<T>
retainAllS
in interface IterableFilterable<T>
retainAllS
in interface PersistentCollectionX<T>
values
- elements to retaindefault <U> PStackX<U> cast(java.lang.Class<? extends U> type)
Transformable
ClassCastException
.
// ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)cast
in interface CollectionX<T>
cast
in interface PersistentCollectionX<T>
cast
in interface Transformable<T>
default <C extends java.util.Collection<? super T>> PStackX<C> grouped(int size, java.util.function.Supplier<C> supplier)
Traversable
assertThat(ReactiveSeq.of(1,1,1,1,1,1)
.batchBySize(3,()->new TreeSet<>())
.toList()
.get(0)
.size(),is(1));
grouped
in interface CollectionX<T>
grouped
in interface PersistentCollectionX<T>
grouped
in interface Traversable<T>
size
- batch sizesupplier
- Collection factorydefault PStackX<ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.groupedUntil(i->i%3==0)
.toList()
.size(),equalTo(2));
groupedUntil
in interface CollectionX<T>
groupedUntil
in interface PersistentCollectionX<T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, transform open next batchdefault PStackX<ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.groupedStatefullyUntil((s,i)->s.contains(4) ? true : false)
.toList().size(),equalTo(5));
groupedStatefullyUntil
in interface CollectionX<T>
groupedStatefullyUntil
in interface PersistentCollectionX<T>
groupedStatefullyUntil
in interface Traversable<T>
predicate
- Window while truedefault PStackX<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.groupedWhile(i->i%3!=0)
.toList().size(),equalTo(2));
groupedWhile
in interface CollectionX<T>
groupedWhile
in interface PersistentCollectionX<T>
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, transform open next batchdefault <C extends java.util.Collection<? super T>> PStackX<C> groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.batchWhile(i->i%3!=0)
.toList()
.size(),equalTo(2));
groupedWhile
in interface CollectionX<T>
groupedWhile
in interface PersistentCollectionX<T>
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, transform open next batchfactory
- Collection factorydefault <C extends java.util.Collection<? super T>> PStackX<C> groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)
Traversable
ReactiveSeq.of(1,2,3,4,5,6)
.groupedUntil(i->i%3!=0)
.toList()
//2
groupedUntil
in interface CollectionX<T>
groupedUntil
in interface PersistentCollectionX<T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, transform open next batchfactory
- Collection factorydefault <R> PStackX<R> retry(java.util.function.Function<? super T,? extends R> fn)
Transformable
given(serviceMock.apply(anyInt())).willThrow(
new RuntimeException(new SocketException("First")),
new RuntimeException(new IOException("Second"))).willReturn(
"42");
String result = ReactiveSeq.of( 1, 2, 3)
.retry(serviceMock)
.firstValue();
//result = 42
retry
in interface Transformable<T>
fn
- Function to retry if failsdefault <R> PStackX<R> retry(java.util.function.Function<? super T,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit)
Transformable
given(serviceMock.apply(anyInt())).willThrow(
new RuntimeException(new SocketException("First")),
new RuntimeException(new IOException("Second"))).willReturn(
"42");
String result = ReactiveSeq.of( 1, 2, 3)
.retry(serviceMock, 7, 2, TimeUnit.SECONDS)
.firstValue();
//result = 42
retry
in interface Transformable<T>
fn
- Function to retry if failsretries
- Number of retriesdelay
- Delay in TimeUnitstimeUnit
- TimeUnit to use for delaydefault <R> PStackX<R> flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)
flatMapS
in interface CollectionX<T>
flatMapS
in interface PersistentCollectionX<T>
default <R> PStackX<R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
flatMapP
in interface CollectionX<T>
flatMapP
in interface PersistentCollectionX<T>
default PStackX<T> prependS(java.util.stream.Stream<? extends T> stream)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3)
.prependS(of(100, 200, 300))
.map(it -> it + "!!")
.collect(Collectors.toList());
assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
prependS
in interface PersistentCollectionX<T>
prependS
in interface Traversable<T>
stream
- to Prependdefault PStackX<T> append(T... values)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3).append(100, 200, 300).map(it -> it + "!!").collect(Collectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!"))); *
append
in interface PersistentCollectionX<T>
append
in interface Traversable<T>
values
- to appenddefault PStackX<T> append(T value)
append
in interface PersistentCollectionX<T>
append
in interface Traversable<T>
default PStackX<T> prepend(T value)
prepend
in interface PersistentCollectionX<T>
prepend
in interface Traversable<T>
default PStackX<T> prepend(T... values)
Traversable
List<String> result = ReactiveSeq.of(1,2,3)
.prepend(100,200,300)
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
prepend
in interface PersistentCollectionX<T>
prepend
in interface Traversable<T>
values
- to prependdefault PStackX<T> insertAt(int pos, T... values)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3).insertAt(1, 100, 200, 300).map(it -> it + "!!").collect(Collectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!"))); *
insertAt
in interface PersistentCollectionX<T>
insertAt
in interface Traversable<T>
pos
- to insert data atvalues
- to insertdefault PStackX<T> deleteBetween(int start, int end)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).deleteBetween(2, 4).map(it -> it + "!!").collect(Collectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "5!!", "6!!"))); *
deleteBetween
in interface PersistentCollectionX<T>
deleteBetween
in interface Traversable<T>
start
- indexend
- indexdefault PStackX<T> insertAtS(int pos, java.util.stream.Stream<T> stream)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3).insertAtS(1, of(100, 200, 300)).map(it -> it + "!!").collect(Collectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
insertAtS
in interface PersistentCollectionX<T>
insertAtS
in interface Traversable<T>
pos
- to insert Stream atstream
- to insertdefault PStackX<T> recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4)
.map(i->i+2)
.map(u->{throw new RuntimeException();})
.recover(e->"hello")
.firstValue(),equalTo("hello"));
recover
in interface Traversable<T>
fn
- Function that accepts a Throwable and returns an alternative
valuedefault <EX extends java.lang.Throwable> PStackX<T> recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<? super EX,? extends T> fn)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4)
.map(i->i+2)
.map(u->{ExceptionSoftener.throwSoftenedException( new IOException()); return null;})
.recover(IOException.class,e->"hello")
.firstValue(),equalTo("hello"));
recover
in interface Traversable<T>
exceptionClass
- Type to recover fromfn
- That accepts an error and returns an alternative valuedefault PStackX<T> plusLoop(int max, java.util.function.IntFunction<T> value)
plusLoop
in interface FluentCollectionX<T>