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 toNested 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 toNested 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 toNested Stream#collect
|
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 toNested a Stream with the values repeated specified times
|
default AnyMSeq<W,T> |
cycle(Monoid<T> m,
long times)
Convert toNested 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 empty 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 toNested 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 toNested 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 toNested 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 toNested 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 collection 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 toNested 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 empty, 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 empty, 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 empty, 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 toNested 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 toNested 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 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 <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 <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 <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 AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index toNested the current Stream
|
ap, ap2, coflatMapA, eqv, flatten, flattenI, fromArray, fromBagX, fromCollectionX, fromCompletableFuture, fromDeque, fromDoubleStream, fromEither, fromEither3, fromEither4, fromEither5, fromEval, fromFuture, fromFutureStream, fromIntStream, fromIor, fromLinkedListX, fromList, fromLongStream, fromMaybe, fromMonadicValue, fromOptional, fromOptionalDouble, fromOptionalInt, fromOptionalLong, fromOrderedSetX, fromPersistentQueueX, fromPersistentSetX, fromPublisher, fromQueue, fromRange, fromRangeLong, fromSet, fromSortedSet, fromStream, fromStream, fromStream, fromStreamable, fromTry, fromVectorX, fromXor, iterator, 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, narrow, nestA, ofNullable, ofSeq, ofValue, ofValue, reactiveSeq, sequence, sequence, streamOf, toString, traverse, traverse, zip3, zip4, zipP, zipWith, zipWithP, zipWithS
unwrap, unwrapIfInstance
futureStream, getStreamable, isEmpty, jdkStream, reveresedJDKStream, reveresedStream
asFunction, foldFuture, foldLazy, foldTry, forEachSubscribe, forEachSubscribe, forEachSubscribe, headAndTail, runFuture, runLazy, seq, toListX, toSetX, visit
allMatch, anyMatch, collectors, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, maxBy, min, minBy, mode, noneMatch, sum, sumDouble, sumInt, sumLong, toList, toMap, toMap, toSet, toString, toString
endsWith, 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, singleOptional, startsWith, startsWithIterable, xMatch
drop, mapToDouble, mapToInt, mapToLong, take
removeAll, removeAllI, removeAllS, retainAll, retainAllI, retainAllS
groupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT
fixedDelay, onePer, xPer
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)
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 toNested iterate overmonad2
- Nested Monad toNested iterate overmonad3
- Nested Monad toNested iterate overyieldingFunction
- Function with pointers toNested 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 toNested iterate overmonad2
- Nested Monad toNested iterate overmonad3
- Nested Monad toNested iterate overfilterFunction
- Filter toNested apply over elements before passing non-filtered
values toNested the yielding functionyieldingFunction
- Function with pointers toNested 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 toNested iterate overyieldingFunction
- Function with pointers toNested 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 toNested iterate overfilterFunction
- Filter toNested apply over elements before passing non-filtered values toNested the yielding functionyieldingFunction
- Function with pointers toNested 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 toNested flatMap overmonad2
- Nested monad toNested flatMap overfilterFunction
- Filter toNested apply over elements before passing non-filtered values toNested the yielding functionyieldingFunction
- Function with pointers toNested 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 toNested iterate overmonad2
- Nested Stream toNested iterate overyieldingFunction
- Function with pointers toNested 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 toNested compare toNesteddefault <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 toNested 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 toNested 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 toNested return (last elements)default AnyMSeq<W,T> onEmpty(T value)
OnEmpty
default AnyMSeq<W,T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
OnEmpty
onEmptyGet
in interface OnEmpty<T>
onEmptyGet
in interface Traversable<T>
supplier
- toNested determine new value for containerFunctionalAdapter<W> adapter()
default <X extends java.lang.Throwable> AnyMSeq<W,T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
OnEmpty
onEmptyThrow
in interface OnEmpty<T>
onEmptyThrow
in interface Traversable<T>
supplier
- toNested 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)
Transformable
ClassCastException
.
// ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)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 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 toNested 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)
Zippable
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)
Zippable
default <U> AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)
Zippable
default <U> AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
Zippable
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)
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, apply 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),Semigroups.intSum)
.listX()
//ListX(3,4)
combine
in interface Traversable<T>
predicate
- Test toNested see if two neighbours should be joined. The first parameter toNested the bi-predicate is the currently
accumulated result and the second is the next elementop
- BinaryOperator toNested 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 toNested @see Traversable.combine(BiPredicate, BinaryOperator)
but differs in that the first comparison is always toNested the Monoid zero
This allows us toNested terminate with just a single valuecombine
in interface Traversable<T>
op
- Monoid toNested combine neighbourspredicate
- Test toNested see if two neighbours should be joined. The first parameter toNested 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, apply 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, apply 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, apply 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)
Traversable
grouped
in interface Traversable<T>
classifier
- Grouping functiondownstream
- Collector toNested create the grouping collectiondefault <K> AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
Traversable
grouped
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 toNested 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 toNested 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 toNested 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 toNested 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 toNested 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 toNested 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 toNested 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 toNested skip until truedefault AnyMSeq<W,T> intersperse(T value)
Traversable
intersperse
in interface Traversable<T>
default AnyMSeq<W,T> skipLast(int num)
Traversable
skipLast
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()
ExtendedTraversable
permutations
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 toNested 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.empty()]
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 toNested 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.apply(anyInt())).willThrow(
new RuntimeException(new SocketException("First")),
new RuntimeException(new IOException("Second"))).willReturn(
"42");
String result = ReactiveSeq.of( 1, 2, 3)
.retry(serviceMock)
.firstValue();
//result = 42
retry
in interface AnyM<W extends WitnessType<W>,T>
retry
in interface Transformable<T>
fn
- Function toNested 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.apply(anyInt())).willThrow(
new RuntimeException(new SocketException("First")),
new RuntimeException(new IOException("Second"))).willReturn(
"42");
String result = ReactiveSeq.of( 1, 2, 3)
.retry(serviceMock, 7, 2, TimeUnit.SECONDS)
.firstValue();
//result = 42
retry
in interface AnyM<W extends WitnessType<W>,T>
retry
in interface Transformable<T>
fn
- Function toNested retry if failsretries
- Number of retriesdelay
- Delay in TimeUnitstimeUnit
- TimeUnit toNested 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
- toNested 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
- toNested 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
- toNested 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
- toNested insert data atvalues
- toNested 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
- toNested insert Stream atstream
- toNested 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 toNested 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> empty=ints.empty();
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)