T - Data types of elements managed by wrapped non-scalar Monad.public interface AnyMSeq<W extends WitnessType<W>,T> extends AnyM<W,T>, FoldableTraversable<T>, org.reactivestreams.Publisher<T>
AnyM.AnyMFactory| Modifier and Type | Method and Description |
|---|---|
FunctionalAdapter<W> |
adapter() |
default AnyMSeq<W,java.util.List<T>> |
aggregate(AnyM<W,T> next)
Aggregate the contents of this Monad and the supplied Monad
|
default AnyMSeq<W,T> |
append(T... values)
Append values to the take of this ReactiveSeq
|
default AnyMSeq<W,T> |
append(T value) |
default <U> AnyMSeq<W,U> |
cast(java.lang.Class<? extends U> type)
Cast all elements in a reactiveStream to a given type, possibly throwing a
ClassCastException. |
default <R,A> R |
collect(java.util.stream.Collector<? super T,A,R> collector)
Collect the contents of the monad wrapped by this AnyM into supplied collector
A mutable reduction operation equivalent to Stream#collect
|
default org.jooq.lambda.Collectable<T> |
collectors()
Narrow this class to a Collectable
|
default AnyMSeq<W,ReactiveSeq<T>> |
combinations()
Generate the combinations based on values in the ExtendedTraversable.
|
default AnyMSeq<W,ReactiveSeq<T>> |
combinations(int size)
Generate the combinations based on values in the ExtendedTraversable.
|
default AnyMSeq<W,T> |
combine(java.util.function.BiPredicate<? super T,? super T> predicate,
java.util.function.BinaryOperator<T> op)
Combine two adjacent elements in a traversable using the supplied BinaryOperator
This is a stateful grouping and reduction operation.
|
default AnyMSeq<W,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.
|
default AnyMSeq<W,T> |
cycle(long times)
Convert to a Stream with the values repeated specified times
|
default AnyMSeq<W,T> |
cycle(Monoid<T> m,
long times)
Convert to a Stream with the result of a reduction operation repeated
specified times
|
default AnyMSeq<W,T> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
default AnyMSeq<W,T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
default AnyMSeq<W,T> |
deleteBetween(int start,
int end)
Delete elements between given indexes in a Stream
|
default AnyMSeq<W,T> |
distinct() |
default AnyMSeq<W,T> |
dropRight(int num)
Generate a new Traversable that drops the specified number elements from the take of this Traversable
|
default AnyMSeq<W,T> |
dropUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that drops elements from this Traversable until the predicate holds
|
default AnyMSeq<W,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
|
default <T> AnyMSeq<W,T> |
empty()
Construct an AnyM wrapping a new zero instance of the wrapped type
e.g.
|
default <T> AnyMSeq<W,T> |
emptyUnit() |
default boolean |
eqv(AnyMSeq<?,T> t)
Equivalence test, returns true if this Monad is equivalent to the supplied monad
e.g.
|
default AnyMSeq<W,T> |
filter(java.util.function.Predicate<? super T> p)
Perform a filter operation on the wrapped monad instance e.g.
|
default AnyMSeq<W,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> AnyMSeq<W,R> |
flatMap(java.util.function.Function<? super T,? extends AnyM<W,? extends R>> fn) |
default <R> AnyMSeq<W,R> |
flatMapA(java.util.function.Function<? super T,? extends AnyM<W,? extends R>> fn) |
default <R> AnyMSeq<W,R> |
flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn) |
default <R> AnyMSeq<W,R> |
flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn) |
default <R> AnyMSeq<W,R> |
flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn) |
static <W extends WitnessType<W>,T1> |
flatten(AnyMSeq<W,AnyMSeq<W,T1>> nested) |
default <X extends java.lang.Throwable> |
forEach(java.util.function.Consumer<? super T> consumerElement,
java.util.function.Consumer<? super java.lang.Throwable> consumerError)
Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,
|
default <X extends java.lang.Throwable> |
forEach(java.util.function.Consumer<? super T> consumerElement,
java.util.function.Consumer<? super java.lang.Throwable> consumerError,
java.lang.Runnable onComplete)
Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers
when the entire Stream has been processed an onComplete event will be recieved.
|
default <X extends java.lang.Throwable> |
forEach(long numberOfElements,
java.util.function.Consumer<? super T> consumer)
Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from
the Stream, at this time.
|
default <X extends java.lang.Throwable> |
forEach(long numberOfElements,
java.util.function.Consumer<? super T> consumer,
java.util.function.Consumer<? super java.lang.Throwable> consumerError)
Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming
the specified number of elements from the Stream, at this time.
|
default <X extends java.lang.Throwable> |
forEach(long numberOfElements,
java.util.function.Consumer<? super T> consumer,
java.util.function.Consumer<? super java.lang.Throwable> consumerError,
java.lang.Runnable onComplete)
Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming
the specified number of elements from the Stream, at this time.
|
default <R1,R> AnyMSeq<W,R> |
forEach2(java.util.function.Function<? super T,? extends AnyM<W,R1>> monad,
java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
Perform a two level nested internal iteration over this Stream and the supplied monad (allowing null handling, exception handling
etc to be injected, for example)
|
default <R1,R> AnyMSeq<W,R> |
forEach2(java.util.function.Function<? super T,? extends AnyM<W,R1>> monad,
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 monad (allowing null handling, exception handling
etc to be injected, for example)
|
default <R1,R2,R> AnyMSeq<W,R> |
forEach3(java.util.function.Function<? super T,? extends AnyM<W,R1>> monad1,
java.util.function.BiFunction<? super T,? super R1,? extends AnyM<W,R2>> monad2,
Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
Perform a three level nested internal iteration over this AnyM and the supplied monads
|
default <R1,R2,R> AnyMSeq<W,R> |
forEach3(java.util.function.Function<? super T,? extends AnyM<W,R1>> monad1,
java.util.function.BiFunction<? super T,? super R1,? extends AnyM<W,R2>> monad2,
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 AnyM<W,R1>> monad1,
java.util.function.BiFunction<? super T,? super R1,? extends AnyM<W,R2>> monad2,
Fn3<? super T,? super R1,? super R2,? extends AnyM<W,R3>> monad3,
Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
Perform a four level nested internal iteration over this monad and the
supplied monads
|
default <R1,R2,R3,R> |
forEach4(java.util.function.Function<? super T,? extends AnyM<W,R1>> monad1,
java.util.function.BiFunction<? super T,? super R1,? extends AnyM<W,R2>> monad2,
Fn3<? super T,? super R1,? super R2,? extends AnyM<W,R3>> monad3,
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 four level nested internal iteration over this monad and the
supplied monads
|
default <T> AnyMSeq<W,T> |
fromIterable(java.lang.Iterable<T> t) |
default <K> AnyMSeq<W,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> AnyMSeq<W,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 AnyMSeq<W,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 AnyMSeq<W,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 AnyMSeq<W,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 AnyMSeq<W,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 AnyMSeq<W,T> |
insertAt(int pos,
T... values)
Insert data into a reactiveStream at given position
|
default AnyMSeq<W,T> |
insertAtS(int pos,
java.util.stream.Stream<T> stream)
Insert a Stream into the middle of this reactiveStream at the specified position
|
default AnyMSeq<W,T> |
intersperse(T value)
Returns a reactiveStream with a given value interspersed between any two values
of this reactiveStream.
|
default AnyMSeq<W,T> |
limit(long num)
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3)); |
default AnyMSeq<W,T> |
limitLast(int num)
Limit results to the last x elements in a SequenceM
|
default AnyMSeq<W,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 AnyMSeq<W,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> AnyMSeq<W,R> |
map(java.util.function.Function<? super T,? extends R> fn)
Transform this functor using the supplied transformation function
|
default Xor<AnyMValue<W,T>,AnyMSeq<W,T>> |
matchable()
Allows structural matching on the value / seq nature of this AnyM.
|
default AnyMSeq<W,T> |
mergeP(org.reactivestreams.Publisher<T>... publishers) |
default AnyMSeq<W,T> |
mergeP(QueueFactory<T> factory,
org.reactivestreams.Publisher<T>... publishers) |
default <U> AnyMSeq<W,U> |
ofType(java.lang.Class<? extends U> type)
Keep only those elements in a reactiveStream that are of a given type.
|
default AnyMSeq<W,T> |
onEmpty(T value)
If this Container instance is zero, create a new instance containing the provided value
|
default AnyMSeq<W,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 <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 AnyMSeq<W,T> |
peek(java.util.function.Consumer<? super T> c)
Perform a peek operation on the wrapped monad e.g.
|
default AnyMSeq<W,ReactiveSeq<T>> |
permutations()
Generate the permutations based on values in the ExtendedTraversable.
|
default AnyMSeq<W,T> |
prepend(T... values)
Prepend given values to the skip of the Stream
|
default AnyMSeq<W,T> |
prepend(T value) |
default AnyMSeq<W,T> |
prependS(java.util.stream.Stream<? extends T> stream)
Prepend Stream to this ReactiveSeq
|
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 AnyMSeq<W,T> |
recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)
Recover from an exception with an alternative value
|
default <R> AnyMSeq<W,R> |
retry(java.util.function.Function<? super T,? extends R> fn)
Retry a transformation if it fails.
|
default <R> AnyMSeq<W,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 AnyMSeq<W,T> |
reverse()
Potentially efficient Stream reversal.
|
default AnyMSeq<W,T> |
scanLeft(Monoid<T> monoid)
Scan left using supplied Monoid
|
default <U> AnyMSeq<W,U> |
scanLeft(U seed,
java.util.function.BiFunction<? super U,? super T,? extends U> function)
Scan left
|
default AnyMSeq<W,T> |
scanRight(Monoid<T> monoid)
Scan right
|
default <U> AnyMSeq<W,U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Scan right
|
default org.jooq.lambda.Seq<T> |
seq() |
default AnyMSeq<W,T> |
shuffle() |
default AnyMSeq<W,T> |
shuffle(java.util.Random random) |
default AnyMSeq<W,T> |
skip(long num)
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); |
default AnyMSeq<W,T> |
skipLast(int num)
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2)
.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
|
default AnyMSeq<W,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 AnyMSeq<W,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 AnyMSeq<W,T> |
slice(long from,
long to) |
default AnyMSeq<W,VectorX<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
default AnyMSeq<W,VectorX<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
default AnyMSeq<W,T> |
sorted()
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
default AnyMSeq<W,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) |
ReactiveSeq<T> |
stream() |
default void |
subscribe(org.reactivestreams.Subscriber<? super T> sub) |
default AnyMSeq<W,T> |
takeRight(int num)
Generate a new Traversable that takes the specified number elements from the take of this Traversable
|
default AnyMSeq<W,T> |
takeUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that takes elements from this Traversable until the predicate holds
|
default AnyMSeq<W,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 ConvertableSequence<T> |
to() |
default Value<T> |
toFirstValue() |
default <R> AnyMSeq<W,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
|
default Traversable<T> |
traversable() |
default <T> AnyMSeq<W,T> |
unit(T value)
Construct a new instanceof AnyM using the type of the underlying wrapped monad
|
default <U> AnyMSeq<W,U> |
unitIterator(java.util.Iterator<U> U)
Create an IterableFunctor instance of the same type from an Iterator
|
default AnyMSeq<W,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> AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.lang.Iterable<? extends U> other)
Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
|
default <U,R> AnyMSeq<W,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> AnyMSeq<W,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> AnyMSeq<W,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> AnyMSeq<W,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> AnyMSeq<W,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> AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<T,U>> |
zipP(org.reactivestreams.Publisher<? extends U> other) |
default <U> AnyMSeq<W,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> AnyMSeq<W,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> AnyMSeq<W,R> |
zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn) |
default AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
default <R> AnyMSeq<W,R> |
zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn) |
default <R> AnyMSeq<W,R> |
zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn) |
always, always, ap, ap2, coflatMapA, completableFutureOf, eqv, failure, flatten, flattenI, fromArray, fromBagX, fromCollectionX, fromCompletableFuture, fromDeque, fromDoubleStream, fromEither, fromEither3, fromEither4, fromEither5, fromEval, fromFuture, fromFutureStream, fromIdentity, fromIntStream, fromIor, fromLinkedListX, fromList, fromLongStream, fromMaybe, fromMonadicValue, fromOptional, fromOptionalDouble, fromOptionalInt, fromOptionalLong, fromOrderedSetX, fromPersistentQueueX, fromPersistentSetX, fromPublisher, fromQueue, fromSet, fromSortedSet, fromStream, fromStream, fromStream, fromStreamable, fromTry, fromVectorX, fromXor, futureOf, generate, identity, iterator, just, later, left, liftF, liftF2, liftF2, liftF3, liftF3, liftF4, liftF4, liftF5, liftF5, liftMFuture, liftMFuture, liftMList, liftMListX, listFromCompletableFuture, listFromEither, listFromEither3, listFromEither4, listFromEither5, listFromEval, listFromFuture, listFromIor, listFromMaybe, listFromOptional, listFromStream, listFromStreamable, listFromXor, listOf, maybeNullable, narrow, nestA, none, notNull, ofNullable, ofSeq, ofValue, ofValue, ofValue2, ofValue2, primary, rangeLongOf, rangeOf, reactiveSeq, right, secondary, sequence, sequence, streamOf, success, success, toString, traverse, traverseunwrap, unwrapIfInstance, unwrapNestedfutureStream, getStreamable, isEmpty, jdkStream, reveresedJDKStream, reveresedStreamasFunction, foldFuture, foldLazy, foldTry, forEachSubscribe, forEachSubscribe, forEachSubscribe, headAndTail, runFuture, runLazy, toListX, toSetX, visitallMatch, anyMatch, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, maxBy, min, minBy, mode, noneMatch, sum, sumDouble, sumInt, sumLong, toList, toMap, toMap, toSet, toString, toStringendsWith, endsWithIterable, findAny, findFirst, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleUnsafe, startsWith, startsWithIterable, takeOne, xMatchdrop, mapToDouble, mapToInt, mapToLong, takeremoveAll, removeAllI, removeAllS, retainAll, retainAllI, retainAllSgroupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingTfixedDelay, onePer, xPerdefault <R> AnyMSeq<W,R> flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)
default <R> AnyMSeq<W,R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
default <R> AnyMSeq<W,R> flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)
default <R1,R2,R3,R> AnyMSeq<W,R> forEach4(java.util.function.Function<? super T,? extends AnyM<W,R1>> monad1, java.util.function.BiFunction<? super T,? super R1,? extends AnyM<W,R2>> monad2, Fn3<? super T,? super R1,? super R2,? extends AnyM<W,R3>> monad3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
monad1 - Nested Monad to iterate overmonad2 - Nested Monad to iterate overmonad3 - Nested Monad to iterate overyieldingFunction - Function with pointers to the current element from both
Monad that generates the new elementsdefault <R1,R2,R3,R> AnyMSeq<W,R> forEach4(java.util.function.Function<? super T,? extends AnyM<W,R1>> monad1, java.util.function.BiFunction<? super T,? super R1,? extends AnyM<W,R2>> monad2, Fn3<? super T,? super R1,? super R2,? extends AnyM<W,R3>> monad3, 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)
monad1 - Nested Monad to iterate overmonad2 - Nested Monad to iterate overmonad3 - Nested Monad 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> AnyMSeq<W,R> forEach2(java.util.function.Function<? super T,? extends AnyM<W,R1>> monad, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
AnyM.fromArray(1,2,3)
.forEachAnyM2(a->AnyM.fromIntStream(IntStream.range(10,13)),
(a,b)->a+b);
//AnyM[11,14,12,15,13,16]
monad - Nested Monad to iterate overyieldingFunction - Function with pointers to the current element from both Streams that generates the new elementsdefault <R1,R> AnyMSeq<W,R> forEach2(java.util.function.Function<? super T,? extends AnyM<W,R1>> monad, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
AnyM.fromArray(1,2,3)
.forEach2(a->AnyM.fromIntStream(IntStream.range(10,13)),
(a,b)-> a<3 && b>10,
(a,b)->a+b);
//AnyM[14,15]
monad - Nested Monad 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 monads that generates the new elementsdefault <R1,R2,R> AnyMSeq<W,R> forEach3(java.util.function.Function<? super T,? extends AnyM<W,R1>> monad1, java.util.function.BiFunction<? super T,? super R1,? extends AnyM<W,R2>> monad2, Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
AnyM.fromArray(1,2)
.forEach3(a->AnyM.fromIntStream(IntStream.range(10,13)),
(a,b)->AnyM.fromArray(""+(a+b),"hello world"),
(a,b,c)->AnyM.fromArray(""+(a+b),"hello world"),
(a,b,c,d)->c+":"a+":"+b);
monad1 - Nested monad to flatMap overmonad2 - Nested monad to flatMap overfilterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding functionyieldingFunction - Function with pointers to the current element from both monads that generates the new elementsdefault <R1,R2,R> AnyMSeq<W,R> forEach3(java.util.function.Function<? super T,? extends AnyM<W,R1>> monad1, java.util.function.BiFunction<? super T,? super R1,? extends AnyM<W,R2>> monad2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
AnyM.fromArray(1,2,3)
.forEach3(a->AnyM.fromStream(IntStream.range(10,13)),
(a,b)->AnyM.fromArray(""+(a+b),"hello world"),
(a,b,c)-> c!=3,
(a,b,c)->c+":"a+":"+b);
//AnyM[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]
monad1 - Nested Stream to iterate overmonad2 - Nested Stream to iterate overyieldingFunction - Function with pointers to the current element from both Monads that generates the new elementsdefault boolean eqv(AnyMSeq<?,T> t)
{code
Stream.of(1) and Arrays.asList(1) are equivalent
}
t - Monad to compare todefault <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
AnyM
AnyM<Integer> monad1 = AnyM.fromStream(Stream.of(1,2,3));
AnyM<Integer> monad2 = AnyM.fromOptional(Optional.of(1));
List<Integer> list1 = monad1.collect(CyclopsCollectors.toList());
List<Integer> list2 = monad2.collect(CyclopsCollectors.toList());
collect in interface AnyM<W extends WitnessType<W>,T>collect in interface CyclopsCollectable<T>collector - JDK collector to perform mutable reductiondefault Traversable<T> traversable()
traversable in interface Traversable<T>default AnyMSeq<W,T> limit(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
limit in interface Traversable<T>num - Limit element size to numdefault AnyMSeq<W,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 Traversable<T>p - Limit while predicate is truedefault AnyMSeq<W,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 Traversable<T>p - Limit until predicate is truedefault AnyMSeq<W,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 Traversable<T>num - of elements to return (last elements)default AnyMSeq<W,T> onEmpty(T value)
OnEmptydefault AnyMSeq<W,T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
OnEmptyonEmptyGet in interface OnEmpty<T>onEmptyGet in interface Traversable<T>supplier - to determine new value for containerFunctionalAdapter<W> adapter()
default <X extends java.lang.Throwable> AnyMSeq<W,T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
OnEmptyonEmptyThrow in interface OnEmpty<T>onEmptyThrow in interface Traversable<T>supplier - to create exception fromdefault void subscribe(org.reactivestreams.Subscriber<? super T> sub)
subscribe in interface org.reactivestreams.Publisher<T>subscribe in interface Traversable<T>default <U> AnyMSeq<W,U> cast(java.lang.Class<? extends U> type)
TransformableClassCastException.
// ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)cast in interface AnyM<W extends WitnessType<W>,T>cast in interface Transformable<T>default <R> AnyMSeq<W,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 AnyM<W extends WitnessType<W>,T>trampoline in interface Transformable<T>mapper - TCO Transformation functiondefault AnyMSeq<W,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 Traversable<T>times - Times values should be repeated within a Streamdefault AnyMSeq<W,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 Traversable<T>m - Monoid to be used in reductiontimes - Number of times value should be repeateddefault AnyMSeq<W,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 Traversable<T>predicate - repeat while truedefault Xor<AnyMValue<W,T>,AnyMSeq<W,T>> matchable()
AnyM
AnyM<String> monad;
monad.matchable().visit(v->handleValue(v.get()),s->handleSequence(s.toList()));
default <T> AnyMSeq<W,T> fromIterable(java.lang.Iterable<T> t)
fromIterable in interface AnyM<W extends WitnessType<W>,T>default AnyMSeq<W,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 Traversable<T>predicate - repeat while truedefault <U,R> AnyMSeq<W,R> zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippabledefault <U,R> AnyMSeq<W,R> zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippabledefault <U> AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)
Zippabledefault <U> AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
Zippabledefault <S,U> AnyMSeq<W,org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)
Zippable
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']]
default <T2,T3,T4> AnyMSeq<W,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)
Zippable
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"]]
default AnyMSeq<W,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 Traversable<T>default AnyMSeq<W,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 Traversable<T>windowSize - Size of sliding windowdefault AnyMSeq<W,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 Traversable<T>windowSize - number of elements in each batchincrement - for each windowdefault <C extends java.util.Collection<? super T>> AnyMSeq<W,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 Traversable<T>size - batch sizesupplier - Collection factorydefault AnyMSeq<W,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 Traversable<T>predicate - Batch until predicate holds, applyHKT open next batchdefault AnyMSeq<W,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 Traversable<T>predicate - Window while truedefault AnyMSeq<W,T> combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)
Traversable
ReactiveSeq.of(1,1,2,3)
.combine((a, b)->a.equals(b),SemigroupK.intSum)
.listX()
//ListX(3,4)
combine in interface Traversable<T>predicate - 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 elementop - BinaryOperator to combine neighboursdefault AnyMSeq<W,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 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 AnyMSeq<W,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 Traversable<T>predicate - Batch while predicate holds, applyHKT open next batchdefault <C extends java.util.Collection<? super T>> AnyMSeq<W,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 Traversable<T>predicate - Batch while predicate holds, applyHKT open next batchfactory - Collection factorydefault <C extends java.util.Collection<? super T>> AnyMSeq<W,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 Traversable<T>predicate - Batch until predicate holds, applyHKT open next batchfactory - Collection factorydefault AnyMSeq<W,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 Traversable<T>groupSize - Size of each Groupdefault <K,A,D> AnyMSeq<W,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)
Traversablegrouped in interface Traversable<T>classifier - Grouping functiondownstream - Collector to create the grouping toXdefault <K> AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
Traversablegrouped in interface Traversable<T>classifier - Grouping functiondefault AnyMSeq<W,T> takeWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeWhile(i<3);
//[1,2]
takeWhile in interface Traversable<T>p - Predicate to determine when values should be takendefault AnyMSeq<W,T> dropWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropWhile(i<3);
//[3]
dropWhile in interface Traversable<T>p - Predicate to determine when values should be droppeddefault AnyMSeq<W,T> takeUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeUntil(i<2);
//[1,2]
takeUntil in interface Traversable<T>p - Predicate to determine when values should be taken untildefault AnyMSeq<W,T> dropUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropUntil(i>2);
//[3]
dropUntil in interface Traversable<T>p - Predicate to determine when values should be droppeddefault AnyMSeq<W,T> dropRight(int num)
Traversable
ListX.of(1,2,3).dropRight(2);
//[1]
dropRight in interface Traversable<T>num - Drop this number of elements from the take of this Traversabledefault AnyMSeq<W,T> takeRight(int num)
Traversable
ListX.of(1,2,3).takeRight(2);
//[2,3]
takeRight in interface Traversable<T>num - Take this number of elements from the take of this Traversabledefault AnyMSeq<W,T> reverse()
Traversable assertThat( of(1, 2, 3).reverse().toList(),
equalTo(asList(3, 2, 1))); reverse in interface Traversable<T>default AnyMSeq<W,T> shuffle(java.util.Random random)
shuffle in interface Traversable<T>default AnyMSeq<W,T> scanLeft(Monoid<T> monoid)
Traversable
assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
.scanLeft(Reducers.toString("")).toList());
scanLeft in interface Traversable<T>default <U> AnyMSeq<W,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 Traversable<T>default AnyMSeq<W,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 Traversable<T>default <U> AnyMSeq<W,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 Traversable<T>default AnyMSeq<W,T> sorted()
Traversable
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));
sorted in interface Traversable<T>default AnyMSeq<W,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 Traversable<T>c - Compartor to sort withdefault AnyMSeq<W,T> skip(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));
skip in interface Traversable<T>num - Number of elemenets to skipdefault AnyMSeq<W,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 Traversable<T>p - Predicate to skip while truedefault AnyMSeq<W,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 Traversable<T>p - Predicate to skip until truedefault AnyMSeq<W,T> intersperse(T value)
Traversableintersperse in interface Traversable<T>default AnyMSeq<W,T> skipLast(int num)
TraversableskipLast in interface Traversable<T>default AnyMSeq<W,T> slice(long from, long to)
slice in interface Traversable<T>default <U extends java.lang.Comparable<? super U>> AnyMSeq<W,T> sorted(java.util.function.Function<? super T,? extends U> function)
sorted in interface Traversable<T>default AnyMSeq<W,ReactiveSeq<T>> permutations()
ExtendedTraversablepermutations in interface ExtendedTraversable<T>default AnyMSeq<W,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 ExtendedTraversable<T>size - of combinationsdefault AnyMSeq<W,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 ExtendedTraversable<T>default <U> AnyMSeq<W,U> ofType(java.lang.Class<? extends U> type)
Filters
// (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
default AnyMSeq<W,T> filterNot(java.util.function.Predicate<? super T> fn)
Filters
of(1,2,3).filter(i->i>2);
//[1,2]
default <U> AnyMSeq<W,U> unitIterator(java.util.Iterator<U> U)
Traversable
ReactiveSeq<Integer> newSeq = seq.unitIterable(myIterator);
unitIterator in interface AnyM<W extends WitnessType<W>,T>unitIterator in interface Traversable<T>U - Iterator to create new IterableFunctor fromdefault AnyMSeq<W,T> filter(java.util.function.Predicate<? super T> p)
AnyM
AnyM.fromOptional(Optional.of(10)).filter(i->i<10);
//AnyM[Optional.zero()]
AnyM.fromStream(Stream.of(5,10)).filter(i->i<10);
//AnyM[Stream[5]]
default <R> AnyMSeq<W,R> map(java.util.function.Function<? super T,? extends R> fn)
Transformable
of(1,2,3).map(i->i*2)
//[2,4,6]
map in interface AnyM<W extends WitnessType<W>,T>map in interface FilterableTransformable<T>map in interface Transformable<T>fn - Transformation functiondefault <X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(long numberOfElements,
java.util.function.Consumer<? super T> consumer)
ReactiveStreamsTerminalOperations
Subscription next = ReactiveSeq.of(1,2,3,4)
.forEach(2,System.out::println);
System.out.println("First batch processed!");
next.request(2);
System.out.println("Second batch processed!");
//prints
1
2
First batch processed!
3
4
Second batch processed!
forEach in interface FoldableTraversable<T>forEach in interface ReactiveStreamsTerminalOperations<T>numberOfElements - To consume from the Stream at this timeconsumer - To accept incoming events from the Streamdefault <X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(long numberOfElements,
java.util.function.Consumer<? super T> consumer,
java.util.function.Consumer<? super java.lang.Throwable> consumerError)
ReactiveStreamsTerminalOperations
Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
.map(Supplier::get)
.forEach(2,System.out::println, e->e.printStackTrace());
System.out.println("First batch processed!");
next.request(2);
System.out.println("Second batch processed!");
//prints
1
2
First batch processed!
RuntimeException Stack Trace on System.err
4
Second batch processed!
forEach in interface FoldableTraversable<T>forEach in interface ReactiveStreamsTerminalOperations<T>numberOfElements - To consume from the Stream at this timeconsumer - To accept incoming elements from the StreamconsumerError - To accept incoming processing errors from the Streamdefault <X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(long numberOfElements,
java.util.function.Consumer<? super T> consumer,
java.util.function.Consumer<? super java.lang.Throwable> consumerError,
java.lang.Runnable onComplete)
ReactiveStreamsTerminalOperations
Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
.map(Supplier::get)
.forEach(2,System.out::println, e->e.printStackTrace(),()->System.out.println("the take!"));
System.out.println("First batch processed!");
next.request(2);
System.out.println("Second batch processed!");
//prints
1
2
First batch processed!
RuntimeException Stack Trace on System.err
4
Second batch processed!
The take!
forEach in interface FoldableTraversable<T>forEach in interface ReactiveStreamsTerminalOperations<T>numberOfElements - To consume from the Stream at this timeconsumer - To accept incoming elements from the StreamconsumerError - To accept incoming processing errors from the StreamonComplete - To run after an onComplete eventdefault <X extends java.lang.Throwable> void forEach(java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError)
ReactiveStreamsTerminalOperations
Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
.map(Supplier::get)
.forEach(System.out::println, e->e.printStackTrace());
System.out.println("processed!");
//prints
1
2
RuntimeException Stack Trace on System.err
4
processed!
forEach in interface FoldableTraversable<T>forEach in interface ReactiveStreamsTerminalOperations<T>consumerElement - To accept incoming elements from the StreamconsumerError - To accept incoming processing errors from the Streamdefault <X extends java.lang.Throwable> void forEach(java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)
ReactiveStreamsTerminalOperations
Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
.map(Supplier::get)
.forEachEvents(System.out::println, e->e.printStackTrace(),()->System.out.println("the take!"));
System.out.println("processed!");
//prints
1
2
RuntimeException Stack Trace on System.err
4
processed!
forEach in interface FoldableTraversable<T>forEach in interface ReactiveStreamsTerminalOperations<T>consumerElement - To accept incoming elements from the StreamconsumerError - To accept incoming processing errors from the StreamonComplete - To run after an onComplete eventdefault AnyMSeq<W,T> peek(java.util.function.Consumer<? super T> c)
AnyM
AnyM.fromCompletableFuture(CompletableFuture.supplyAsync(()->loadData())
.peek(System.out::println)
peek in interface AnyM<W extends WitnessType<W>,T>peek in interface Transformable<T>c - Consumer to accept current datastatic <W extends WitnessType<W>,T1> AnyMSeq<W,T1> flatten(AnyMSeq<W,AnyMSeq<W,T1>> nested)
default AnyMSeq<W,java.util.List<T>> aggregate(AnyM<W,T> next)
AnyM
AnyM.fromStream(Stream.of(1,2,3,4))
.aggregate(fromEither5(Optional.of(5)))
AnyM[Stream[List[1,2,3,4,5]]
List<Integer> result = AnyM.fromStream(Stream.of(1,2,3,4))
.aggregate(fromEither5(Optional.of(5)))
.toSequence()
.flatten()
.toList();
assertThat(result,equalTo(Arrays.asList(1,2,3,4,5)));
default <R> AnyMSeq<W,R> flatMapA(java.util.function.Function<? super T,? extends AnyM<W,? extends R>> fn)
default <R> AnyMSeq<W,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 AnyM<W extends WitnessType<W>,T>retry in interface Transformable<T>fn - Function to retry if failsdefault <R> AnyMSeq<W,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 AnyM<W extends WitnessType<W>,T>retry in interface Transformable<T>fn - Function to retry if failsretries - Number of retriesdelay - Delay in TimeUnitstimeUnit - TimeUnit to use for delaydefault AnyMSeq<W,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 Traversable<T>stream - to Prependdefault AnyMSeq<W,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 Traversable<T>values - to appenddefault AnyMSeq<W,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 Traversable<T>values - to prependdefault AnyMSeq<W,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 Traversable<T>pos - to insert data atvalues - to insertdefault AnyMSeq<W,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 Traversable<T>start - indexend - indexdefault AnyMSeq<W,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 Traversable<T>pos - to insert Stream atstream - to insertdefault AnyMSeq<W,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> AnyMSeq<W,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 <T> AnyMSeq<W,T> unit(T value)
AnyM
AnyM<Integer> ints = AnyM.fromList(Arrays.asList(1,2,3);
AnyM<String> string = ints.unit("hello");
default <T> AnyMSeq<W,T> empty()
AnyM
Any<Integer> ints = AnyM.fromStream(Stream.of(1,2,3));
AnyM<Integer> zero=ints.zero();
default <R> AnyMSeq<W,R> flatMap(java.util.function.Function<? super T,? extends AnyM<W,? extends R>> fn)
ReactiveSeq<T> stream()
stream in interface AnyM<W extends WitnessType<W>,T>stream in interface ExtendedTraversable<T>stream in interface FoldableTraversable<T>stream in interface Folds<T>stream in interface Sequential<T>stream in interface ToStream<T>stream in interface TransformerTraversable<T>stream in interface Traversable<T>default ConvertableSequence<T> to()
to in interface CyclopsCollectable<T>default AnyMSeq<W,T> mergeP(QueueFactory<T> factory, org.reactivestreams.Publisher<T>... publishers)
default AnyMSeq<W,T> zip(java.util.function.BinaryOperator<Zippable<T>> combiner, Zippable<T> app)
Zippablezip in interface AnyM<W extends WitnessType<W>,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> AnyMSeq<W,R> zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)
default <R> AnyMSeq<W,R> zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)
default <R> AnyMSeq<W,R> zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)
default <T2,R> AnyMSeq<W,R> zipP(org.reactivestreams.Publisher<? extends T2> publisher, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
Zippabledefault <U> AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<T,U>> zipP(org.reactivestreams.Publisher<? extends U> other)
default <S,U,R> AnyMSeq<W,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,R> AnyMSeq<W,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 org.jooq.lambda.Collectable<T> collectors()
collectors in interface CyclopsCollectable<T>default org.jooq.lambda.Seq<T> seq()
seq in interface FoldableTraversable<T>