T
- the type of elements held in this collectionpublic interface PersistentSetX<T> extends To<PersistentSetX<T>>, org.pcollections.PSet<T>, Higher<Witness.persistentSetX,T>, LazyCollectionX<T>, OnEmptySwitch<T,org.pcollections.PSet<T>>
Modifier and Type | Interface and Description |
---|---|
static class |
PersistentSetX.CompletablePersistentSetX<T> |
static class |
PersistentSetX.Instances |
Modifier and Type | Method and Description |
---|---|
default Active<Witness.persistentSetX,T> |
allTypeclasses() |
default AnyMSeq<Witness.persistentSetX,T> |
anyM() |
default PersistentSetX<T> |
append(T... values)
Append values to the take of this ReactiveSeq
|
default PersistentSetX<T> |
append(T value) |
default <U> PersistentSetX<U> |
cast(java.lang.Class<? extends U> type)
Cast all elements in a reactiveStream to a given type, possibly throwing a
ClassCastException . |
default <R> PersistentSetX<R> |
coflatMap(java.util.function.Function<? super PersistentSetX<T>,? extends R> fn)
coflatMap pattern, can be used to perform lazy reductions / collections / folds and other terminal operations
|
default PersistentSetX<ReactiveSeq<T>> |
combinations()
Generate the combinations based on values in the ExtendedTraversable.
|
default PersistentSetX<ReactiveSeq<T>> |
combinations(int size)
Generate the combinations based on values in the ExtendedTraversable.
|
default PersistentSetX<T> |
combine(java.util.function.BiPredicate<? super T,? super T> predicate,
java.util.function.BinaryOperator<T> op)
Combine two adjacent elements in a PersistentSetX using the supplied BinaryOperator
This is a stateful grouping & reduction operation.
|
default PersistentSetX<T> |
combine(Monoid<T> op,
java.util.function.BiPredicate<? super T,? super T> predicate)
Combine two adjacent elements in a traversable using the supplied BinaryOperator
This is a stateful grouping and reduction operation.
|
static <T> PersistentSetX.CompletablePersistentSetX<T> |
completable() |
default <W1> Coproduct<W1,Witness.persistentSetX,T> |
coproduct(InstanceDefinitions<W1> def2) |
default LinkedListX<T> |
cycle(long times)
Convert to a Stream with the values repeated specified times
|
default LinkedListX<T> |
cycle(Monoid<T> m,
long times)
Convert to a Stream with the result of a reduction operation repeated
specified times
|
default LinkedListX<T> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
default LinkedListX<T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
default PersistentSetX<T> |
deleteBetween(int start,
int end)
Delete elements between given indexes in a Stream
|
default PersistentSetX<T> |
distinct() |
default PersistentSetX<T> |
drop(long num)
assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7))); |
default PersistentSetX<T> |
dropRight(int num)
Generate a new Traversable that drops the specified number elements from the take of this Traversable
|
default PersistentSetX<T> |
dropUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that drops elements from this Traversable until the predicate holds
|
default PersistentSetX<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
|
PersistentSetX<T> |
eager() |
static <T> PersistentSetX<T> |
empty() |
default <R> PersistentSetX<R> |
emptyUnit() |
default PersistentSetX<T> |
filter(java.util.function.Predicate<? super T> pred)
Keep only elements for which the supplied predicates hold
e.g.
|
default PersistentSetX<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> PersistentSetX<R> |
flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
Perform a flatMap operation on this toX.
|
default <R> PersistentSetX<R> |
flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn) |
default <R> PersistentSetX<R> |
flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn) |
default <R1,R> PersistentSetX<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 reactiveStream
|
default <R1,R> PersistentSetX<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 reactiveStream
|
default <R1,R2,R> PersistentSetX<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> PersistentSetX<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> PersistentSetX<X> |
from(java.util.Collection<X> col)
Conctruct an Extended Collection from a standard Collection
|
static <T> PersistentSetX<T> |
fromIterable(java.lang.Iterable<T> iterable) |
static <T> PersistentSetX<T> |
fromIterator(java.util.Iterator<T> iterator) |
static <T> PersistentSetX<T> |
fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
Construct a PersistentSetX from an Publisher
|
default <T> PersistentSetX<T> |
fromStream(ReactiveSeq<T> stream) |
static <T> PersistentSetX<T> |
generate(long limit,
java.util.function.Supplier<T> s)
Generate a PersistentSetX from the provided Supplier up to the provided limit number of times
|
default <K> PersistentSetX<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> PersistentSetX<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 PersistentSetX<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 toX created by the
supplied factory
|
default PersistentSetX<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 PersistentSetX<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 PersistentSetX<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 PersistentSetX<T> |
insertAt(int pos,
T... values)
Insert data into a reactiveStream at given position
|
default PersistentSetX<T> |
insertAtS(int pos,
java.util.stream.Stream<T> stream)
Insert a Stream into the middle of this reactiveStream at the specified position
|
default PersistentSetX<T> |
intersperse(T value)
Returns a reactiveStream with a given value interspersed between any two values
of this reactiveStream.
|
static <T> PersistentSetX<T> |
iterate(long limit,
T seed,
java.util.function.UnaryOperator<T> f)
Create a PersistentSetX by iterative application of a function to an initial element up to the supplied limit number of times
|
static <T> Cokleisli<Witness.persistentSetX,T,PersistentSetX<T>> |
kindCokleisli() |
static <T> Kleisli<Witness.persistentSetX,PersistentSetX<T>,T> |
kindKleisli() |
PersistentSetX<T> |
lazy() |
default PersistentSetX<T> |
limit(long num)
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3)); |
default PersistentSetX<T> |
limitLast(int num)
Limit results to the last x elements in a SequenceM
|
default PersistentSetX<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 PersistentSetX<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> PersistentSetX<R> |
map(java.util.function.Function<? super T,? extends R> mapper)
Transform this functor using the supplied transformation function
|
default <W2,R> Nested<Witness.persistentSetX,W2,R> |
mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn,
InstanceDefinitions<W2> defs) |
default PersistentSetX<T> |
materialize() |
PersistentSetX<T> |
minus(java.lang.Object e)
Remove the specified element from this toX
|
PersistentSetX<T> |
minusAll(java.util.Collection<?> list)
Remove all the specified elements from this toX
|
default <T> Reducer<org.pcollections.PSet<T>> |
monoid() |
static <T> PersistentSetX<T> |
narrow(PersistentSetX<? extends T> setX)
Narrow a covariant PersistentSetX
|
static <T> PersistentSetX<T> |
narrowK(Higher<Witness.persistentSetX,T> persistentSetX) |
static <W1,T> Nested<Witness.persistentSetX,W1,T> |
nested(PersistentSetX<Higher<W1,T>> nested,
InstanceDefinitions<W1> def2) |
default PersistentSetX<T> |
notNull()
Filter elements retaining only values which are not null
|
static <T> PersistentSetX<T> |
of(T... values) |
default <U> PersistentSetX<U> |
ofType(java.lang.Class<? extends U> type)
Keep only those elements in a reactiveStream that are of a given type.
|
default PersistentSetX<T> |
onEmpty(T value)
If this Container instance is zero, create a new instance containing the provided value
|
default PersistentSetX<T> |
onEmptyGet(java.util.function.Supplier<? extends T> supplier)
If this Container instance is zero, create a new instance containing the value returned from the provided Supplier
|
default PersistentSetX<T> |
onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PSet<T>> supplier)
Switch to container created by provided Supplier, if current Container zero
|
default <X extends java.lang.Throwable> |
onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
If this container instance is zero, throw the exception returned by the provided Supplier
|
default PersistentSetX<ReactiveSeq<T>> |
permutations()
Generate the permutations based on values in the ExtendedTraversable.
|
static <T> PersistentSetX<T> |
persistentSetX(ReactiveSeq<T> stream)
import static cyclops.stream.ReactiveSeq.range;
PeristentSetX<Integer> bag = persistentSetX(range(10,20));
|
PersistentSetX<T> |
plus(T e)
Add an element to this Collection
|
PersistentSetX<T> |
plusAll(java.util.Collection<? extends T> list)
Add all supplied elements to this Collection
|
default PersistentSetX<T> |
plusInOrder(T e)
Add an element to the toX
|
default PersistentSetX<T> |
plusLoop(int max,
java.util.function.IntFunction<T> value) |
default PersistentSetX<T> |
plusLoop(java.util.function.Supplier<java.util.Optional<T>> supplier) |
default PersistentSetX<T> |
prepend(T... values)
Prepend given values to the skip of the Stream
|
default PersistentSetX<T> |
prepend(T value) |
default PersistentSetX<T> |
prependS(java.util.stream.Stream<? extends T> stream)
Prepend Stream to this ReactiveSeq
|
default <W1> Product<Witness.persistentSetX,W1,T> |
product(Active<W1,T> active) |
static PersistentSetX<java.lang.Integer> |
range(int start,
int end)
Create a PersistentSetX that contains the Integers between skip and take
|
static PersistentSetX<java.lang.Long> |
rangeLong(long start,
long end)
Create a PersistentSetX 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 PersistentSetX<T> |
recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)
Recover from an exception with an alternative value
|
default PersistentSetX<T> |
removeAll(T... values)
Remove all supplied elements from this filterable
|
default PersistentSetX<T> |
removeAllI(java.lang.Iterable<? extends T> it)
Remove all elements in the supplied Iterable from this filterable
|
default PersistentSetX<T> |
removeAllS(java.util.stream.Stream<? extends T> stream)
Remove all elements in the supplied Stream from this filterable
|
default PersistentSetX<T> |
retainAll(T... values)
Retain only the supplied elements in the returned Filters
|
default PersistentSetX<T> |
retainAllI(java.lang.Iterable<? extends T> it)
Retain only the supplied elements in the returned Filters
|
default PersistentSetX<T> |
retainAllS(java.util.stream.Stream<? extends T> seq)
Retain only the supplied elements in the returned Filters
|
default <R> PersistentSetX<R> |
retry(java.util.function.Function<? super T,? extends R> fn)
Retry a transformation if it fails.
|
default <R> PersistentSetX<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 PersistentSetX<T> |
reverse()
Potentially efficient Stream reversal.
|
default PersistentSetX<T> |
scanLeft(Monoid<T> monoid)
Scan left using supplied Monoid
|
default <U> PersistentSetX<U> |
scanLeft(U seed,
java.util.function.BiFunction<? super U,? super T,? extends U> function)
Scan left
|
default PersistentSetX<T> |
scanRight(Monoid<T> monoid)
Scan right
|
default <U> PersistentSetX<U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Scan right
|
default PersistentSetX<T> |
shuffle() |
default PersistentSetX<T> |
shuffle(java.util.Random random) |
static <T> PersistentSetX<T> |
singleton(T value) |
default PersistentSetX<T> |
skip(long num)
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); |
default PersistentSetX<T> |
skipLast(int num)
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2)
.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
|
default PersistentSetX<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 PersistentSetX<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 PersistentSetX<T> |
slice(long from,
long to) |
default PersistentSetX<VectorX<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
default PersistentSetX<VectorX<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
default PersistentSetX<T> |
sorted()
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
default PersistentSetX<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() |
static <T,R> PersistentSetX<R> |
tailRec(T initial,
java.util.function.Function<? super T,? extends PersistentSetX<? extends Xor<T,R>>> fn) |
default PersistentSetX<T> |
take(long num)
assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3)); |
default PersistentSetX<T> |
takeRight(int num)
Generate a new Traversable that takes the specified number elements from the take of this Traversable
|
default PersistentSetX<T> |
takeUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that takes elements from this Traversable until the predicate holds
|
default PersistentSetX<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 <R> PersistentSetX<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
|
PersistentSetX<T> |
type(Reducer<? extends org.pcollections.PSet<T>> reducer) |
static <U,T> PersistentSetX<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 PersistentSetX
|
default <R> PersistentSetX<R> |
unit(java.util.Collection<R> col)
Create a new instance of the same colleciton type from the supplied toX
|
default <R> PersistentSetX<R> |
unit(R value) |
default <R> PersistentSetX<R> |
unitIterator(java.util.Iterator<R> it)
Create an IterableFunctor instance of the same type from an Iterator
|
static <T> Higher<Witness.persistentSetX,T> |
widen(PersistentSetX<T> narrow) |
default PersistentSetX<T> |
zip(java.util.function.BinaryOperator<Zippable<T>> combiner,
Zippable<T> app)
Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all
extend BinaryOperator - checkout SemigroupK and Monoids for a large number of canned combinations).
|
default <U> PersistentSetX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.lang.Iterable<? extends U> other)
Zip (merge) this toX with the supplied Iterable into a Colleciton containing Tuples
Each Tuple contains one element from this toX and one from the other
|
default <U,R> PersistentSetX<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> PersistentSetX<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 <S,U,R> PersistentSetX<R> |
zip3(java.lang.Iterable<? extends S> second,
java.lang.Iterable<? extends U> third,
Fn3<? super T,? super S,? super U,? extends R> fn3) |
default <T2,T3,T4> PersistentSetX<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 <T2,T3,T4,R> |
zip4(java.lang.Iterable<? extends T2> second,
java.lang.Iterable<? extends T3> third,
java.lang.Iterable<? extends T4> fourth,
Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn) |
default <T2,R> PersistentSetX<R> |
zipP(org.reactivestreams.Publisher<? extends T2> publisher,
java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
|
default <U> PersistentSetX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zipP(org.reactivestreams.Publisher<? extends U> other) |
default <U> PersistentSetX<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> PersistentSetX<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 <R> PersistentSetX<R> |
zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn) |
default PersistentSetX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
default <R> PersistentSetX<R> |
zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn) |
default <R> PersistentSetX<R> |
zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn) |
add, addAll, clear, remove, removeAll, retainAll
add, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, remove, removeAll, retainAll, size, spliterator, toArray, toArray
flatMapP, reduce
evaluation, findAny, findFirst, fromCollection, getAtIndex, groupBy, head, headAndTail, isEager, isLazy, isMaterialized, materializeReversed, peek, single, single, singleUnsafe, takeOne, toX
asFunction, foldFuture, foldLazy, foldTry, forEach, forEach, forEach, forEach, forEach, forEachSubscribe, forEachSubscribe, forEachSubscribe, runFuture, runLazy, seq, toListX, toSetX, visit
allMatch, anyMatch, collect, collectors, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, maxBy, min, minBy, mode, noneMatch, sum, sumDouble, sumInt, sumLong, to, toList, toMap, toMap, 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, schedule, scheduleFixedDelay, scheduleFixedRate, startsWith, startsWithIterable, xMatch
mapToDouble, mapToInt, mapToLong, subscribe, traversable
groupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT
fixedDelay, onePer, xPer
unwrap, unwrapIfInstance, unwrapNested
PersistentSetX<T> lazy()
lazy
in interface CollectionX<T>
PersistentSetX<T> eager()
eager
in interface CollectionX<T>
static <T> PersistentSetX.CompletablePersistentSetX<T> completable()
static <T> Kleisli<Witness.persistentSetX,PersistentSetX<T>,T> kindKleisli()
static <T> Higher<Witness.persistentSetX,T> widen(PersistentSetX<T> narrow)
static <T> Cokleisli<Witness.persistentSetX,T,PersistentSetX<T>> kindCokleisli()
static <W1,T> Nested<Witness.persistentSetX,W1,T> nested(PersistentSetX<Higher<W1,T>> nested, InstanceDefinitions<W1> def2)
default <W1> Product<Witness.persistentSetX,W1,T> product(Active<W1,T> active)
default <W1> Coproduct<W1,Witness.persistentSetX,T> coproduct(InstanceDefinitions<W1> def2)
default Active<Witness.persistentSetX,T> allTypeclasses()
default <W2,R> Nested<Witness.persistentSetX,W2,R> mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs)
static <T> PersistentSetX<T> narrow(PersistentSetX<? extends T> setX)
PersistentSetX<? extends Fruit> set = PersistentSetX.of(apple,bannana);
PersistentSetX<Fruit> fruitSet = PersistentSetX.narrowK(set);
setX
- to narrowK generic typestatic PersistentSetX<java.lang.Integer> range(int start, int end)
start
- Number of range to skip fromend
- Number for range to take atstatic PersistentSetX<java.lang.Long> rangeLong(long start, long end)
start
- Number of range to skip fromend
- Number for range to take atstatic <U,T> PersistentSetX<T> unfold(U seed, java.util.function.Function<? super U,java.util.Optional<org.jooq.lambda.tuple.Tuple2<T,U>>> unfolder)
PersistentSetX.unfold(1,i->i<=6 ? Optional.of(Tuple.tuple(i,i+1)) : Optional.zero());
//(1,2,3,4,5) in any order
seed
- Initial valueunfolder
- Iteratively applied function, terminated by an zero Optionalstatic <T> PersistentSetX<T> generate(long limit, java.util.function.Supplier<T> s)
limit
- Max number of elements to generates
- Supplier to generate PersistentSetX elementsstatic <T> PersistentSetX<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 elementstatic <T> PersistentSetX<T> of(T... values)
static <T> PersistentSetX<T> empty()
static <T> PersistentSetX<T> singleton(T value)
PersistentSetX<T> type(Reducer<? extends org.pcollections.PSet<T>> reducer)
static <T> PersistentSetX<T> persistentSetX(ReactiveSeq<T> stream)
import static cyclops.stream.ReactiveSeq.range;
PeristentSetX<Integer> bag = persistentSetX(range(10,20));
T
- PersistentSetX generated from Streamstream
- To create a PersistentSetX fromstatic <T> PersistentSetX<T> fromIterable(java.lang.Iterable<T> iterable)
static <T> PersistentSetX<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
publisher
- to construct PersistentSetX fromdefault <T> PersistentSetX<T> fromStream(ReactiveSeq<T> stream)
fromStream
in interface LazyCollectionX<T>
stream
- Create a MultableCollectionX from a Streamdefault <R1,R2,R3,R> PersistentSetX<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> PersistentSetX<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 applyHKT 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> PersistentSetX<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> PersistentSetX<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 applyHKT 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> PersistentSetX<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> PersistentSetX<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 applyHKT 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 AnyMSeq<Witness.persistentSetX,T> anyM()
default PersistentSetX<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 PersistentSetX<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 <R> PersistentSetX<R> coflatMap(java.util.function.Function<? super PersistentSetX<T>,? extends R> fn)
PersistentSetX.of(1,2,3)
.map(i->i*2)
.coflatMap(s -> s.reduce(0,(a,b)->a+b))
//PersistentSetX[12]
fn
- mapping functiondefault PersistentSetX<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)
PersistentSetX.of(1,1,2,3)
.combine((a, b)->a.equals(b),SemigroupK.intSum)
.listX()
//ListX(3,4)
combine
in interface CollectionX<T>
combine
in interface LazyCollectionX<T>
combine
in interface Traversable<T>
predicate
- Test to see if two neighbors should be joinedop
- Reducer to combine neighborsdefault PersistentSetX<T> combine(Monoid<T> op, java.util.function.BiPredicate<? super T,? super T> predicate)
Traversable
ReactiveSeq.of(1,1,2,3)
.combine(Monoids.intMult,(a, b)->a.equals(b))
.listX()
//ListX(1)
Simalar to @see Traversable.combine(BiPredicate, BinaryOperator)
but differs in that the first comparison is always to the Monoid zero
This allows us to terminate with just a single valuecombine
in interface LazyCollectionX<T>
combine
in interface Traversable<T>
op
- Monoid to combine neighbourspredicate
- Test to see if two neighbours should be joined. The first parameter to the bi-predicate is the currently
accumulated result and the second is the next elementdefault <R> PersistentSetX<R> unit(java.util.Collection<R> col)
FluentCollectionX
unit
in interface FluentCollectionX<T>
col
- Collection data to populate the new toXdefault <R> PersistentSetX<R> unit(R value)
default <R> PersistentSetX<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> PersistentSetX<R> emptyUnit()
default PersistentSetX<T> materialize()
materialize
in interface CollectionX<T>
default ReactiveSeq<T> stream()
stream
in interface java.util.Collection<T>
stream
in interface CollectionX<T>
stream
in interface ExtendedTraversable<T>
stream
in interface FoldableTraversable<T>
stream
in interface Folds<T>
stream
in interface Sequential<T>
stream
in interface TransformerTraversable<T>
stream
in interface Traversable<T>
default <X> PersistentSetX<X> from(java.util.Collection<X> col)
CollectionX
from
in interface CollectionX<T>
col
- Collection to extenddefault <T> Reducer<org.pcollections.PSet<T>> monoid()
PersistentSetX<T> plus(T e)
FluentCollectionX
plus
in interface FluentCollectionX<T>
plus
in interface LazyCollectionX<T>
plus
in interface org.pcollections.PCollection<T>
plus
in interface org.pcollections.PSet<T>
e
- Element to addPersistentSetX<T> plusAll(java.util.Collection<? extends T> list)
FluentCollectionX
plusAll
in interface FluentCollectionX<T>
plusAll
in interface LazyCollectionX<T>
plusAll
in interface org.pcollections.PCollection<T>
plusAll
in interface org.pcollections.PSet<T>
list
- of elements to addPersistentSetX<T> minus(java.lang.Object e)
FluentCollectionX
minus
in interface FluentCollectionX<T>
minus
in interface LazyCollectionX<T>
minus
in interface org.pcollections.PCollection<T>
minus
in interface org.pcollections.PSet<T>
e
- Element to removePersistentSetX<T> minusAll(java.util.Collection<?> list)
FluentCollectionX
minusAll
in interface FluentCollectionX<T>
minusAll
in interface LazyCollectionX<T>
minusAll
in interface org.pcollections.PCollection<T>
minusAll
in interface org.pcollections.PSet<T>
list
- of elements to removedefault PersistentSetX<T> reverse()
Traversable
assertThat( of(1, 2, 3).reverse().toList(),
equalTo(asList(3, 2, 1)));
reverse
in interface CollectionX<T>
reverse
in interface LazyCollectionX<T>
reverse
in interface Traversable<T>
default PersistentSetX<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 LazyCollectionX<T>
pred
- to filter elements by, retaining matchesdefault <R> PersistentSetX<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 LazyCollectionX<T>
map
in interface Transformable<T>
mapper
- Transformation functiondefault <R> PersistentSetX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
CollectionX
flatMap
in interface CollectionX<T>
flatMap
in interface LazyCollectionX<T>
mapper
- Transformation function to be applied (and flattened)default PersistentSetX<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 LazyCollectionX<T>
limit
in interface Traversable<T>
num
- Limit element size to numdefault PersistentSetX<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 LazyCollectionX<T>
skip
in interface Traversable<T>
num
- Number of elemenets to skipdefault PersistentSetX<T> takeRight(int num)
Traversable
ListX.of(1,2,3).takeRight(2);
//[2,3]
takeRight
in interface CollectionX<T>
takeRight
in interface LazyCollectionX<T>
takeRight
in interface Traversable<T>
num
- Take this number of elements from the take of this Traversabledefault PersistentSetX<T> dropRight(int num)
Traversable
ListX.of(1,2,3).dropRight(2);
//[1]
dropRight
in interface CollectionX<T>
dropRight
in interface LazyCollectionX<T>
dropRight
in interface Traversable<T>
num
- Drop this number of elements from the take of this Traversabledefault PersistentSetX<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 LazyCollectionX<T>
takeWhile
in interface Traversable<T>
p
- Predicate to determine when values should be takendefault PersistentSetX<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 LazyCollectionX<T>
dropWhile
in interface Traversable<T>
p
- Predicate to determine when values should be droppeddefault PersistentSetX<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 LazyCollectionX<T>
takeUntil
in interface Traversable<T>
p
- Predicate to determine when values should be taken untildefault PersistentSetX<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 LazyCollectionX<T>
dropUntil
in interface Traversable<T>
p
- Predicate to determine when values should be droppeddefault <R> PersistentSetX<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
Transformable
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 LazyCollectionX<T>
trampoline
in interface Transformable<T>
mapper
- TCO Transformation functiondefault PersistentSetX<T> slice(long from, long to)
slice
in interface CollectionX<T>
slice
in interface LazyCollectionX<T>
slice
in interface Traversable<T>
default <U extends java.lang.Comparable<? super U>> PersistentSetX<T> sorted(java.util.function.Function<? super T,? extends U> function)
sorted
in interface CollectionX<T>
sorted
in interface LazyCollectionX<T>
sorted
in interface Traversable<T>
default PersistentSetX<ListX<T>> grouped(int groupSize)
Traversable
List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(CyclopsCollectors.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 LazyCollectionX<T>
grouped
in interface Traversable<T>
groupSize
- Size of each Groupdefault <K,A,D> PersistentSetX<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 LazyCollectionX<T>
grouped
in interface Traversable<T>
classifier
- Grouping functiondownstream
- Collector to create the grouping toXdefault <K> PersistentSetX<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 LazyCollectionX<T>
grouped
in interface Traversable<T>
classifier
- Grouping functiondefault <U> PersistentSetX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
CollectionX
zip
in interface CollectionX<T>
zip
in interface LazyCollectionX<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Collection to merge with this onedefault <U,R> PersistentSetX<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 LazyCollectionX<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- to zip withzipper
- Zip functiondefault <U,R> PersistentSetX<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 LazyCollectionX<T>
zipS
in interface Traversable<T>
zipS
in interface Zippable<T>
other
- Stream to combine withzipper
- Zip / combining functiondefault PersistentSetX<ReactiveSeq<T>> permutations()
ExtendedTraversable
permutations
in interface CollectionX<T>
permutations
in interface ExtendedTraversable<T>
permutations
in interface LazyCollectionX<T>
default PersistentSetX<ReactiveSeq<T>> combinations(int size)
ExtendedTraversable
ExtendedTraversable<Integer> reactiveStream = ReactiveSeq.of(1,2,3);
reactiveStream.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 LazyCollectionX<T>
size
- of combinationsdefault PersistentSetX<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 LazyCollectionX<T>
default PersistentSetX<VectorX<T>> sliding(int windowSize)
Traversable
List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(2).collect(CyclopsCollectors.toList());
assertThat(list.get(0), hasItems(1, 2));
assertThat(list.get(1), hasItems(2, 3));
sliding
in interface CollectionX<T>
sliding
in interface LazyCollectionX<T>
sliding
in interface Traversable<T>
windowSize
- Size of sliding windowdefault PersistentSetX<VectorX<T>> sliding(int windowSize, int increment)
Traversable
List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(CyclopsCollectors.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 LazyCollectionX<T>
sliding
in interface Traversable<T>
windowSize
- number of elements in each batchincrement
- for each windowdefault PersistentSetX<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 LazyCollectionX<T>
scanLeft
in interface Traversable<T>
default <U> PersistentSetX<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 LazyCollectionX<T>
scanLeft
in interface Traversable<T>
default PersistentSetX<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 LazyCollectionX<T>
scanRight
in interface Traversable<T>
default <U> PersistentSetX<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 LazyCollectionX<T>
scanRight
in interface Traversable<T>
default PersistentSetX<T> plusInOrder(T e)
FluentCollectionX
plusInOrder
in interface FluentCollectionX<T>
e
- Element to adddefault LinkedListX<T> cycle(long times)
Traversable
ReactiveSeq.of(1,2,2)
.cycle(3)
.collect(CyclopsCollectors.toList());
//List[1,2,2,1,2,2,1,2,2]
cycle
in interface CollectionX<T>
cycle
in interface LazyCollectionX<T>
cycle
in interface Traversable<T>
times
- Times values should be repeated within a Streamdefault LinkedListX<T> cycle(Monoid<T> m, long times)
Traversable
List<Integer> list = ReactiveSeq.of(1,2,2))
.cycle(Reducers.toCountInt(),3)
.collect(CyclopsCollectors.toList());
//List[3,3,3];
cycle
in interface CollectionX<T>
cycle
in interface LazyCollectionX<T>
cycle
in interface Traversable<T>
m
- Monoid to be used in reductiontimes
- Number of times value should be repeateddefault LinkedListX<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(CyclopsCollectors.toList());
// List(1,2,2,1,2,2)
cycleWhile
in interface CollectionX<T>
cycleWhile
in interface LazyCollectionX<T>
cycleWhile
in interface Traversable<T>
predicate
- repeat while truedefault LinkedListX<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(CyclopsCollectors.toList());
//List[1,2,2,1,2,2,1]
cycleUntil
in interface CollectionX<T>
cycleUntil
in interface LazyCollectionX<T>
cycleUntil
in interface Traversable<T>
predicate
- repeat while truedefault <U> PersistentSetX<org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)
Traversable
zipS
in interface CollectionX<T>
zipS
in interface LazyCollectionX<T>
zipS
in interface Traversable<T>
zipS
in interface Zippable<T>
other
- Stream to combine withdefault <S,U> PersistentSetX<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(CyclopsCollectors.toList());
// [[1,100,'a'],[2,200,'b'],[3,300,'c']]
zip3
in interface CollectionX<T>
zip3
in interface LazyCollectionX<T>
zip3
in interface Traversable<T>
zip3
in interface Zippable<T>
default <T2,T3,T4> PersistentSetX<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(CyclopsCollectors.toList());
// [[1,100,'a',"hello"],[2,200,'b',"world"]]
zip4
in interface CollectionX<T>
zip4
in interface LazyCollectionX<T>
zip4
in interface Traversable<T>
zip4
in interface Zippable<T>
default PersistentSetX<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 LazyCollectionX<T>
zipWithIndex
in interface Traversable<T>
default PersistentSetX<T> distinct()
distinct
in interface CollectionX<T>
distinct
in interface LazyCollectionX<T>
distinct
in interface Traversable<T>
default PersistentSetX<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 LazyCollectionX<T>
sorted
in interface Traversable<T>
default PersistentSetX<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 LazyCollectionX<T>
sorted
in interface Traversable<T>
c
- Compartor to sort withdefault PersistentSetX<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 LazyCollectionX<T>
skipWhile
in interface Traversable<T>
p
- Predicate to skip while truedefault PersistentSetX<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 LazyCollectionX<T>
skipUntil
in interface Traversable<T>
p
- Predicate to skip until truedefault PersistentSetX<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 LazyCollectionX<T>
limitWhile
in interface Traversable<T>
p
- Limit while predicate is truedefault PersistentSetX<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 LazyCollectionX<T>
limitUntil
in interface Traversable<T>
p
- Limit until predicate is truedefault PersistentSetX<T> intersperse(T value)
Traversable
intersperse
in interface CollectionX<T>
intersperse
in interface LazyCollectionX<T>
intersperse
in interface Traversable<T>
default PersistentSetX<T> shuffle()
shuffle
in interface CollectionX<T>
shuffle
in interface LazyCollectionX<T>
shuffle
in interface Traversable<T>
default PersistentSetX<T> skipLast(int num)
Traversable
skipLast
in interface CollectionX<T>
skipLast
in interface LazyCollectionX<T>
skipLast
in interface Traversable<T>
default PersistentSetX<T> limitLast(int num)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5)
.limitLast(2)
.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(4,5)));
limitLast
in interface CollectionX<T>
limitLast
in interface LazyCollectionX<T>
limitLast
in interface Traversable<T>
num
- of elements to return (last elements)default PersistentSetX<T> onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PSet<T>> supplier)
OnEmptySwitch
ListX.zero().onEmptySwitch(()->ListX.of(1));
onEmptySwitch
in interface OnEmptySwitch<T,org.pcollections.PSet<T>>
supplier
- to create replacement containerdefault PersistentSetX<T> onEmpty(T value)
OnEmpty
onEmpty
in interface CollectionX<T>
onEmpty
in interface LazyCollectionX<T>
onEmpty
in interface OnEmpty<T>
onEmpty
in interface Traversable<T>
default PersistentSetX<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
OnEmpty
onEmptyGet
in interface CollectionX<T>
onEmptyGet
in interface LazyCollectionX<T>
onEmptyGet
in interface OnEmpty<T>
onEmptyGet
in interface Traversable<T>
supplier
- to determine new value for containerdefault <X extends java.lang.Throwable> PersistentSetX<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
OnEmpty
onEmptyThrow
in interface CollectionX<T>
onEmptyThrow
in interface LazyCollectionX<T>
onEmptyThrow
in interface OnEmpty<T>
onEmptyThrow
in interface Traversable<T>
supplier
- to create exception fromdefault PersistentSetX<T> shuffle(java.util.Random random)
shuffle
in interface CollectionX<T>
shuffle
in interface LazyCollectionX<T>
shuffle
in interface Traversable<T>
default <U> PersistentSetX<U> ofType(java.lang.Class<? extends U> type)
Filters
// (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
default PersistentSetX<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 LazyCollectionX<T>
fn
- to filter elements by, retaining matchesdefault PersistentSetX<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 LazyCollectionX<T>
default PersistentSetX<T> removeAllS(java.util.stream.Stream<? extends T> stream)
IterableFilterable
removeAllS
in interface CollectionX<T>
removeAllS
in interface IterableFilterable<T>
removeAllS
in interface LazyCollectionX<T>
stream
- of elements to removedefault PersistentSetX<T> removeAllI(java.lang.Iterable<? extends T> it)
IterableFilterable
removeAllI
in interface CollectionX<T>
removeAllI
in interface IterableFilterable<T>
removeAllI
in interface LazyCollectionX<T>
it
- an Iterable of elements to removedefault PersistentSetX<T> removeAll(T... values)
IterableFilterable
removeAll
in interface CollectionX<T>
removeAll
in interface IterableFilterable<T>
removeAll
in interface LazyCollectionX<T>
values
- to removedefault PersistentSetX<T> retainAllI(java.lang.Iterable<? extends T> it)
IterableFilterable
retainAllI
in interface CollectionX<T>
retainAllI
in interface IterableFilterable<T>
retainAllI
in interface LazyCollectionX<T>
it
- Iterable of elements to retaindefault PersistentSetX<T> retainAllS(java.util.stream.Stream<? extends T> seq)
IterableFilterable
retainAllS
in interface CollectionX<T>
retainAllS
in interface IterableFilterable<T>
retainAllS
in interface LazyCollectionX<T>
seq
- of elements to retaindefault PersistentSetX<T> retainAll(T... values)
IterableFilterable
retainAll
in interface CollectionX<T>
retainAll
in interface IterableFilterable<T>
retainAll
in interface LazyCollectionX<T>
values
- elements to retaindefault <U> PersistentSetX<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 LazyCollectionX<T>
cast
in interface Transformable<T>
default <C extends java.util.Collection<? super T>> PersistentSetX<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 LazyCollectionX<T>
grouped
in interface Traversable<T>
size
- batch sizesupplier
- Collection factorydefault PersistentSetX<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 LazyCollectionX<T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, applyHKT open next batchdefault PersistentSetX<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 LazyCollectionX<T>
groupedStatefullyUntil
in interface Traversable<T>
predicate
- Window while truedefault PersistentSetX<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 LazyCollectionX<T>
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, applyHKT open next batchdefault <C extends java.util.Collection<? super T>> PersistentSetX<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 LazyCollectionX<T>
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, applyHKT open next batchfactory
- Collection factorydefault <C extends java.util.Collection<? super T>> PersistentSetX<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 LazyCollectionX<T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, applyHKT open next batchfactory
- Collection factorydefault <R> PersistentSetX<R> retry(java.util.function.Function<? super T,? extends R> fn)
Transformable
given(serviceMock.applyHKT(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 LazyCollectionX<T>
retry
in interface Transformable<T>
fn
- Function to retry if failsdefault <R> PersistentSetX<R> retry(java.util.function.Function<? super T,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit)
Transformable
given(serviceMock.applyHKT(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 LazyCollectionX<T>
retry
in interface Transformable<T>
fn
- Function to retry if failsretries
- Number of retriesdelay
- Delay in TimeUnitstimeUnit
- TimeUnit to use for delaydefault <R> PersistentSetX<R> flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)
flatMapS
in interface CollectionX<T>
flatMapS
in interface LazyCollectionX<T>
default <R> PersistentSetX<R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
flatMapP
in interface CollectionX<T>
flatMapP
in interface LazyCollectionX<T>
default PersistentSetX<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(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
prependS
in interface LazyCollectionX<T>
prependS
in interface Traversable<T>
stream
- to Prependdefault PersistentSetX<T> append(T... values)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3).append(100, 200, 300).map(it -> it + "!!").collect(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!"))); *
append
in interface LazyCollectionX<T>
append
in interface Traversable<T>
values
- to appenddefault PersistentSetX<T> append(T value)
append
in interface LazyCollectionX<T>
append
in interface Traversable<T>
default PersistentSetX<T> prepend(T value)
prepend
in interface LazyCollectionX<T>
prepend
in interface Traversable<T>
default PersistentSetX<T> prepend(T... values)
Traversable
List<String> result = ReactiveSeq.of(1,2,3)
.prepend(100,200,300)
.map(it ->it+"!!")
.collect(CyclopsCollectors.toList());
assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
prepend
in interface LazyCollectionX<T>
prepend
in interface Traversable<T>
values
- to prependdefault PersistentSetX<T> insertAt(int pos, T... values)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3).insertAt(1, 100, 200, 300).map(it -> it + "!!").collect(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!"))); *
insertAt
in interface LazyCollectionX<T>
insertAt
in interface Traversable<T>
pos
- to insert data atvalues
- to insertdefault PersistentSetX<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(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "5!!", "6!!"))); *
deleteBetween
in interface LazyCollectionX<T>
deleteBetween
in interface Traversable<T>
start
- indexend
- indexdefault PersistentSetX<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(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
insertAtS
in interface LazyCollectionX<T>
insertAtS
in interface Traversable<T>
pos
- to insert Stream atstream
- to insertdefault PersistentSetX<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 LazyCollectionX<T>
recover
in interface Traversable<T>
fn
- Function that accepts a Throwable and returns an alternative
valuedefault <EX extends java.lang.Throwable> PersistentSetX<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 LazyCollectionX<T>
recover
in interface Traversable<T>
exceptionClass
- Type to recover fromfn
- That accepts an error and returns an alternative valuedefault PersistentSetX<T> plusLoop(int max, java.util.function.IntFunction<T> value)
plusLoop
in interface FluentCollectionX<T>
default PersistentSetX<T> plusLoop(java.util.function.Supplier<java.util.Optional<T>> supplier)
plusLoop
in interface FluentCollectionX<T>
static <T> PersistentSetX<T> fromIterator(java.util.Iterator<T> iterator)
default PersistentSetX<T> zip(java.util.function.BinaryOperator<Zippable<T>> combiner, Zippable<T> app)
Zippable
zip
in interface LazyCollectionX<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
Semigroup
,
Semigroups
,
Monoid
,
To lift any Semigroup (or monoid) up to handling Applicatives use the combineApplicatives operator in SemigroupK
{@see com.aol.cyclops2.SemigroupK#combineApplicatives(BiFunction) } or Monoids
{ {@see com.aol.cyclops2.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops2.function.Monoid)
}
{@code
BinaryOperator> sumMaybes = SemigroupK.combineScalarFunctors(SemigroupK.intSum);
Maybe.just(1).zip(sumMaybes, Maybe.just(5))
//Maybe.just(6));
}
default <R> PersistentSetX<R> zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)
zipWith
in interface LazyCollectionX<T>
zipWith
in interface Traversable<T>
zipWith
in interface Zippable<T>
default <R> PersistentSetX<R> zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)
zipWithS
in interface LazyCollectionX<T>
zipWithS
in interface Traversable<T>
zipWithS
in interface Zippable<T>
default <R> PersistentSetX<R> zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)
zipWithP
in interface LazyCollectionX<T>
zipWithP
in interface Traversable<T>
zipWithP
in interface Zippable<T>
default <T2,R> PersistentSetX<R> zipP(org.reactivestreams.Publisher<? extends T2> publisher, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
Zippable
zipP
in interface LazyCollectionX<T>
zipP
in interface Traversable<T>
zipP
in interface Zippable<T>
publisher
- to combine withfn
- Zip / combining functiondefault <U> PersistentSetX<org.jooq.lambda.tuple.Tuple2<T,U>> zipP(org.reactivestreams.Publisher<? extends U> other)
zipP
in interface LazyCollectionX<T>
zipP
in interface Traversable<T>
zipP
in interface Zippable<T>
default <S,U,R> PersistentSetX<R> zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Fn3<? super T,? super S,? super U,? extends R> fn3)
zip3
in interface LazyCollectionX<T>
zip3
in interface Traversable<T>
zip3
in interface Zippable<T>
default <T2,T3,T4,R> PersistentSetX<R> zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn)
zip4
in interface LazyCollectionX<T>
zip4
in interface Traversable<T>
zip4
in interface Zippable<T>
static <T> PersistentSetX<T> narrowK(Higher<Witness.persistentSetX,T> persistentSetX)
static <T,R> PersistentSetX<R> tailRec(T initial, java.util.function.Function<? super T,? extends PersistentSetX<? extends Xor<T,R>>> fn)