com.aol.cyclops2.types.anyM

Interface AnyMSeq<W extends WitnessType<W>,T>

Type Parameters:

T - Data types of elements managed by wrapped non-scalar Monad.

All Superinterfaces:

AnyM<W,T>, ConvertableSequence<T>, ConvertableToReactiveSeq<T>, CyclopsCollectable<T>, EmptyUnit<T>, ExtendedTraversable<T>, FilterableTransformable<T>, Filters<T>, Fn1<java.lang.Long,T>, FoldableTraversable<T>, Folds<T>, java.util.function.Function<java.lang.Long,T>, org.jooq.lambda.function.Function1<java.lang.Long,T>, java.lang.Iterable<T>, IterableFilterable<T>, OnEmpty<T>, org.reactivestreams.Publisher<T>, ReactiveStreamsTerminalOperations<T>, Sequential<T>, To<AnyM<W,T>>, ToStream<T>, Transformable<T>, TransformerTraversable<T>, Traversable<T>, Unit<T>, Unwrapable, Zippable<T>

public interface AnyMSeq<W extends WitnessType<W>,T>
extends AnyM<W,T>, FoldableTraversable<T>, org.reactivestreams.Publisher<T>

Wrapper around 'Any' non-scalar 'M'onad

Nested Class Summary

Nested classes/interfaces inherited from interface cyclops.monads.AnyM

AnyM.AnyMFactory

Nested classes/interfaces inherited from interface cyclops.function.Fn1

Fn1.µ, Fn1.FunctionalOperations<T1,R>

Method Summary

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 stream 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 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>	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 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 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> AnyM<W,R>	flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)
default <R> AnyM<W,R>	flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
default <R> AnyM<W,R>	flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)
static <W extends WitnessType<W>,T1> AnyMSeq<W,T1>	flatten(AnyMSeq<W,AnyMSeq<W,T1>> nested)
default <X extends java.lang.Throwable> void	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> void	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> org.reactivestreams.Subscription	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> org.reactivestreams.Subscription	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> 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) 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> 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) Perform a four level nested internal iteration over this monad and the supplied monads
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,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>> AnyMSeq<W,C>	grouped(int size, java.util.function.Supplier<C> supplier) Batch elements in a Stream by size into a collection created by the supplied factory
default 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>> AnyMSeq<W,C>	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>> AnyMSeq<W,C>	groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory) Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds
default AnyMSeq<W,T>	insertAt(int pos, T... values) Insert data into a stream at given position
default AnyMSeq<W,T>	insertAtS(int pos, java.util.stream.Stream<T> stream) Insert a Stream into the middle of this stream at the specified position
default AnyMSeq<W,T>	intersperse(T value) Returns a stream with a given value interspersed between any two values of this stream.
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 <U> AnyMSeq<W,U>	ofType(java.lang.Class<? extends U> type) Keep only those elements in a stream 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> AnyMSeq<W,T>	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 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> AnyMSeq<W,T>	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(Collectors.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,PVectorX<T>>	sliding(int windowSize) Create a sliding view over this Sequence
default AnyMSeq<W,PVectorX<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>> AnyMSeq<W,T>	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 DequeX<T>	toDequeX()
default Value<T>	toFirstValue()
default ListX<T>	toListX()
default PBagX<T>	toPBagX()
default POrderedSetX<T>	toPOrderedSetX()
default PQueueX<T>	toPQueueX()
default PSetX<T>	toPSetX()
default PStackX<T>	toPStackX()
default PVectorX<T>	toPVectorX()
default QueueX<T>	toQueueX()
default SetX<T>	toSetX()
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 to the current Stream

Methods inherited from interface cyclops.monads.AnyM

ap, ap2, coflatMapA, eqv, flatten, flattenI, fromArray, fromCollectionX, fromCompletableFuture, fromDoubleStream, fromEither, fromEither3, fromEither4, fromEither5, fromEval, fromFutureW, fromIntStream, fromIor, fromList, fromLongStream, fromMaybe, fromMonadicValue, fromOptional, fromOptionalDouble, fromOptionalInt, fromOptionalLong, fromPublisher, fromRange, fromRangeLong, fromSet, fromStream, fromStream, fromStream, fromStreamable, fromTry, fromXor, iterator, liftF, liftF2, liftF2, liftF3, liftF3, liftF4, liftF4, liftF5, liftF5, liftMFuture, liftMFuture, liftMList, liftMListX, listFromCompletableFuture, listFromEither, listFromEither3, listFromEither4, listFromEither5, listFromEval, listFromFutureW, 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

Methods inherited from interface com.aol.cyclops2.types.Unwrapable

unwrap

Methods inherited from interface com.aol.cyclops2.types.To

to

Methods inherited from interface com.aol.cyclops2.types.FoldableTraversable

apply, foldFuture, foldLazy, foldTry, headAndTail, runFuture, runLazy, seq, visit

Methods inherited from interface cyclops.function.Fn1

andThen, andThen, bind, compose, functionOps, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, product, reader, λ, λv

Methods inherited from interface org.jooq.lambda.function.Function1

apply, applyPartially, applyPartially, curry, curry, from, toFunction

Methods inherited from interface java.util.function.Function

identity

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

allMatch, anyMatch, avg, avgDouble, avgInt, avgLong, bitAnd, bitAndInt, bitAndLong, bitOr, bitOrInt, bitOrLong, collectable, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, max, max, max, maxAll, maxAll, maxAll, maxAll, maxAllBy, maxAllBy, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, min, minAll, minAll, minAll, minAll, minAllBy, minAllBy, minBy, minBy, mode, modeAll, modeAllBy, modeBy, noneMatch, percentile, percentile, percentileBy, percentileBy, sum, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toMap, toSet, toSet, toString, toString

Methods inherited from interface com.aol.cyclops2.types.Folds

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, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, xMatch

Methods inherited from interface com.aol.cyclops2.types.stream.ConvertableSequence

toFutureStream, toFutureStream, toMapX, toOptional, toPMapX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toValue

Methods inherited from interface com.aol.cyclops2.types.Traversable

drop, mapToDouble, mapToInt, mapToLong, take

Methods inherited from interface com.aol.cyclops2.types.Zippable

zip, zipP

Methods inherited from interface com.aol.cyclops2.types.stream.ToStream

futureStream, getStreamable, isEmpty, jdkStream, reveresedJDKStream, reveresedStream

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Methods inherited from interface com.aol.cyclops2.types.IterableFilterable

removeAllS, removeAllS, removeAllS, retainAllS, retainAllS, retainAllS

Methods inherited from interface com.aol.cyclops2.types.Filters

notNull

Methods inherited from interface com.aol.cyclops2.types.TransformerTraversable

groupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT

Methods inherited from interface com.aol.cyclops2.types.Sequential

fixedDelay, onePer, xPer

Method Detail

flatMapI

default <R> AnyM<W,R> flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)

Specified by:

flatMapI in interface AnyM<W extends WitnessType<W>,T>

flatMapP

default <R> AnyM<W,R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)

Specified by:

flatMapP in interface AnyM<W extends WitnessType<W>,T>

flatMapS

default <R> AnyM<W,R> flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)

Specified by:

flatMapS in interface AnyM<W extends WitnessType<W>,T>

forEach4

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)

Perform a four level nested internal iteration over this monad and the supplied monads

Parameters:

monad1 - Nested Monad to iterate over

monad2 - Nested Monad to iterate over

monad3 - Nested Monad to iterate over

yieldingFunction - Function with pointers to the current element from both Monad that generates the new elements

Returns:

AnyMSeq with elements generated via nested iteration

forEach4

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,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

Parameters:

monad1 - Nested Monad to iterate over

monad2 - Nested Monad to iterate over

monad3 - Nested Monad to iterate over

filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function

yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements

Returns:

ReactiveSeq with elements generated via nested iteration

forEach2

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)

  
 AnyM.fromArray(1,2,3)
                        .forEachAnyM2(a->AnyM.fromIntStream(IntStream.range(10,13)),
                                    (a,b)->a+b);
                                    
 
  //AnyM[11,14,12,15,13,16]
 
 

Parameters:

monad - Nested Monad to iterate over

yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements

Returns:

FutureStream with elements generated via nested iteration

forEach2

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)

  
 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]
 
 

Parameters:

monad - Nested Monad to iterate over

filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function

yieldingFunction - Function with pointers to the current element from both monads that generates the new elements

Returns:

forEach3

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

  
 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);
                                    
 
  
 
 

Parameters:

monad1 - Nested monad to flatMap over

monad2 - Nested monad to flatMap over

filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function

yieldingFunction - Function with pointers to the current element from both monads that generates the new elements

Returns:

AnyM with elements generated via nested iteration

forEach3

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

  
 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]
 
 

Parameters:

monad1 - Nested Stream to iterate over

monad2 - Nested Stream to iterate over

yieldingFunction - Function with pointers to the current element from both Monads that generates the new elements

Returns:

AnyM with elements generated via nested iteration

eqv

default boolean eqv(AnyMSeq<?,T> t)

Equivalence test, returns true if this Monad is equivalent to the supplied monad e.g.

 {code
    Stream.of(1) and Arrays.asList(1) are equivalent
 }
 

Parameters:

t - Monad to compare to

Returns:

true if equivalent

collect

default <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)

Description copied from interface: AnyM

Collect the contents of the monad wrapped by this AnyM into supplied collector A mutable reduction operation equivalent to Stream#collect

 
      AnyM<Integer> monad1 = AnyM.fromStream(Stream.of(1,2,3));
      AnyM<Integer> monad2 = AnyM.fromOptional(Optional.of(1));

      List<Integer> list1 = monad1.collect(Collectors.toList());
      List<Integer> list2 = monad2.collect(Collectors.toList());

 
 

Specified by:

collect in interface AnyM<W extends WitnessType<W>,T>

Specified by:

collect in interface CyclopsCollectable<T>

Parameters:

collector - JDK collector to perform mutable reduction

Returns:

Reduced value

traversable

default Traversable<T> traversable()

Specified by:

traversable in interface Traversable<T>

Returns:

This Traversable converted to a Stream and type narrowed to Traversable

limit

default AnyMSeq<W,T> limit(long num)

Description copied from interface: Traversable

  assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
 

Specified by:

limit in interface Traversable<T>

Parameters:

num - Limit element size to num

Returns:

Monad converted to Stream with elements up to num

limitWhile

default AnyMSeq<W,T> limitWhile(java.util.function.Predicate<? super T> p)

Description copied from interface: Traversable

Take elements from the Stream while the predicate holds, once the predicate returns false all subsequent elements are excluded

  assertThat(ReactiveSeq.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
 

Specified by:

limitWhile in interface Traversable<T>

Parameters:

p - Limit while predicate is true

Returns:

Stream with limited elements

limitUntil

default AnyMSeq<W,T> limitUntil(java.util.function.Predicate<? super T> p)

Description copied from interface: Traversable

Take elements from the Stream until the predicate returns true, after which all elements are excluded.

  assertThat(ReactiveSeq.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3))); 
 

Specified by:

limitUntil in interface Traversable<T>

Parameters:

p - Limit until predicate is true

Returns:

Stream with limited elements

limitLast

default AnyMSeq<W,T> limitLast(int num)

Description copied from interface: Traversable

Limit results to the last x elements in a SequenceM

  
 	assertThat(ReactiveSeq.of(1,2,3,4,5)
 							.limitLast(2)
 							.collect(Collectors.toList()),equalTo(Arrays.asList(4,5)));
 
 
 

Specified by:

limitLast in interface Traversable<T>

Parameters:

num - of elements to return (last elements)

Returns:

SequenceM limited to last num elements

onEmpty

default AnyMSeq<W,T> onEmpty(T value)

Description copied from interface: OnEmpty

If this Container instance is empty, create a new instance containing the provided value

Specified by:

onEmpty in interface OnEmpty<T>

Specified by:

onEmpty in interface Traversable<T>

Returns:

New instance containing value if container is empty, otherwise returns this container

onEmptyGet

default AnyMSeq<W,T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)

Description copied from interface: OnEmpty

If this Container instance is empty, create a new instance containing the value returned from the provided Supplier

Specified by:

onEmptyGet in interface OnEmpty<T>

Specified by:

onEmptyGet in interface Traversable<T>

Parameters:

supplier - to determine new value for container

Returns:

New Container with value if this is empty, otherwise this container

adapter

FunctionalAdapter<W> adapter()

Specified by:

adapter in interface AnyM<W extends WitnessType<W>,T>

onEmptyThrow

default <X extends java.lang.Throwable> AnyMSeq<W,T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)

Description copied from interface: OnEmpty

If this container instance is empty, throw the exception returned by the provided Supplier

Specified by:

onEmptyThrow in interface OnEmpty<T>

Specified by:

onEmptyThrow in interface Traversable<T>

Parameters:

supplier - to create exception from

Returns:

Throw exception if empty, otherwise this container

subscribe

default void subscribe(org.reactivestreams.Subscriber<? super T> sub)

Specified by:

subscribe in interface org.reactivestreams.Publisher<T>

Specified by:

subscribe in interface Traversable<T>

toFirstValue

default Value<T> toFirstValue()

Returns:

The first value of this monad

cast

default <U> AnyMSeq<W,U> cast(java.lang.Class<? extends U> type)

Description copied from interface: Transformable

Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)

Specified by:

cast in interface Transformable<T>

trampoline

default <R> AnyMSeq<W,R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)

Description copied from interface: Transformable

Performs a map operation that can call a recursive method without running out of stack space

 
 ReactiveSeq.of(10,20,30,40)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println); 
    			 
    	Trampoline<Long> fibonacci(int i){
    		return fibonacci(i,1,0);
    	}
    	Trampoline<Long> fibonacci(int n, long a, long b) {
        	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
    	}		 
    			 
 55
    	6765
    	832040
    	102334155
 
 
 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);
    			 
    			 
 completes successfully
 
 

Specified by:

trampoline in interface Transformable<T>

Parameters:

mapper - TCO Transformation function

Returns:

Transformable transformed by the supplied transformation function

cycle

default AnyMSeq<W,T> cycle(long times)

Description copied from interface: Traversable

Convert to a Stream with the values repeated specified times

  
 		ReactiveSeq.of(1,2,2)
 								.cycle(3)
 								.collect(Collectors.toList());
 								
 		//List[1,2,2,1,2,2,1,2,2]
 
 
 

Specified by:

cycle in interface Traversable<T>

Parameters:

times - Times values should be repeated within a Stream

Returns:

Stream with values repeated

cycle

default AnyMSeq<W,T> cycle(Monoid<T> m,
                           long times)

Description copied from interface: Traversable

Convert to a Stream with the result of a reduction operation repeated specified times

  
   List<Integer> list = ReactiveSeq.of(1,2,2))
                                 .cycle(Reducers.toCountInt(),3)
                                 .collect(Collectors.toList());
   //List[3,3,3];
   
 

Specified by:

cycle in interface Traversable<T>

Parameters:

m - Monoid to be used in reduction

times - Number of times value should be repeated

Returns:

Stream with reduced values repeated

cycleWhile

default AnyMSeq<W,T> cycleWhile(java.util.function.Predicate<? super T> predicate)

Description copied from interface: Traversable

Repeat in a Stream while specified predicate holds

 
  MutableInt count = MutableInt.of(0);
  ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6).collect(Collectors.toList());
 
  // List(1,2,2,1,2,2)
 
 

Specified by:

cycleWhile in interface Traversable<T>

Parameters:

predicate - repeat while true

Returns:

Repeating Stream

matchable

default Xor<AnyMValue<W,T>,AnyMSeq<W,T>> matchable()

Description copied from interface: AnyM

Allows structural matching on the value / seq nature of this AnyM. If this AnyM can only store a single value an Xor.secondary with type AnyMValue is returned If this AnyM can store one or many values an Xor.primary with type AnyMSeq is returned

 
    AnyM<String> monad;
    
    monad.matchable().visit(v->handleValue(v.get()),s->handleSequence(s.toList()));
 
 

Specified by:

matchable in interface AnyM<W extends WitnessType<W>,T>

Returns:

An Xor for pattern matching either an AnyMValue or AnyMSeq

fromIterable

default <T> AnyMSeq<W,T> fromIterable(java.lang.Iterable<T> t)

Specified by:

fromIterable in interface AnyM<W extends WitnessType<W>,T>

cycleUntil

default AnyMSeq<W,T> cycleUntil(java.util.function.Predicate<? super T> predicate)

Description copied from interface: Traversable

Repeat in a Stream until specified predicate holds

  
 	MutableInt count =MutableInt.of(0);
 		ReactiveSeq.of(1,2,2)
 		 		.cycleUntil(next -> count.get()>6)
 		 		.peek(i-> count.mutate(i->i+1))
 		 		.collect(Collectors.toList());
 
 		//List[1,2,2,1,2,2,1]	
 
 

Specified by:

cycleUntil in interface Traversable<T>

Parameters:

predicate - repeat while true

Returns:

Repeating Stream

zip

default <U,R> AnyMSeq<W,R> zip(java.lang.Iterable<? extends U> other,
                               java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Iterable using the supplied combining function

Specified by:

zip in interface Traversable<T>

Specified by:

zip in interface Zippable<T>

Parameters:

other - to zip with

zipper - Zip function

Returns:

Combined zippable

zipS

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)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Stream, using the supplied combining function

Specified by:

zipS in interface Zippable<T>

Parameters:

other - Stream to combine with

zipper - Zip / combining function

Returns:

Combined zippable

zipS

default <U> AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2

Specified by:

zipS in interface Traversable<T>

Specified by:

zipS in interface Zippable<T>

Parameters:

other - Stream to combine with

Returns:

Combined Zippable

zip

default <U> AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2

Specified by:

zip in interface Zippable<T>

Parameters:

other - Iterable to combine with

Returns:

zip3

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)

Description copied from interface: Zippable

zip 3 Streams into one

 
  List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(Collectors.toList());

  // [[1,100,'a'],[2,200,'b'],[3,300,'c']]
 

 

Specified by:

zip3 in interface AnyM<W extends WitnessType<W>,T>

Specified by:

zip3 in interface Traversable<T>

Specified by:

zip3 in interface Zippable<T>

zip4

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)

Description copied from interface: Zippable

zip 4 Streams into 1

 
  List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
          .collect(Collectors.toList());

 
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 

Specified by:

zip4 in interface AnyM<W extends WitnessType<W>,T>

Specified by:

zip4 in interface Traversable<T>

Specified by:

zip4 in interface Zippable<T>

zipWithIndex

default AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()

Description copied from interface: Traversable

Add an index to the current Stream

  
 assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").zipWithIndex().toList());
 
 

Specified by:

zipWithIndex in interface Traversable<T>

sliding

default AnyMSeq<W,PVectorX<T>> sliding(int windowSize)

Description copied from interface: Traversable

Create a sliding view over this Sequence

 
  List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(2).collect(Collectors.toList());
 
  assertThat(list.get(0), hasItems(1, 2));
  assertThat(list.get(1), hasItems(2, 3));
 
 
 
 

Specified by:

sliding in interface Traversable<T>

Parameters:

windowSize - Size of sliding window

Returns:

SequenceM with sliding view

sliding

default AnyMSeq<W,PVectorX<T>> sliding(int windowSize,
                                       int increment)

Description copied from interface: Traversable

Create a sliding view over this Sequence

 
  List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(Collectors.toList());
 
  assertThat(list.get(0), hasItems(1, 2, 3));
  assertThat(list.get(1), hasItems(3, 4, 5));     
 
 
 
 
 

Specified by:

sliding in interface Traversable<T>

Parameters:

windowSize - number of elements in each batch

increment - for each window

Returns:

SequenceM with sliding view

grouped

default <C extends java.util.Collection<? super T>> AnyMSeq<W,C> grouped(int size,
                                                                         java.util.function.Supplier<C> supplier)

Description copied from interface: Traversable

Batch elements in a Stream by size into a collection created by the supplied factory

 
 assertThat(ReactiveSeq.of(1,1,1,1,1,1)
                      .batchBySize(3,()->new TreeSet<>())
                      .toList()
                      .get(0)
                      .size(),is(1));
 
 

Specified by:

grouped in interface Traversable<T>

Parameters:

size - batch size

supplier - Collection factory

Returns:

SequenceM batched into collection types by size

groupedUntil

default AnyMSeq<W,ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)

Description copied from interface: Traversable

Create a Traversable batched by List, where each batch is populated until the predicate holds

  
  assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .groupedUntil(i->i%3==0)
              .toList()
              .size(),equalTo(2));
 
 

Specified by:

groupedUntil in interface Traversable<T>

Parameters:

predicate - Batch until predicate holds, transform open next batch

Returns:

SequenceM batched into lists determined by the predicate supplied

groupedStatefullyUntil

default AnyMSeq<W,ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)

Description copied from interface: Traversable

Create Travesable of Lists where each List is populated while the supplied bipredicate holds. The bipredicate recieves the List from the last window as well as the current value and can choose to aggregate the current value or create a new window

  
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .groupedStatefullyUntil((s,i)->s.contains(4) ? true : false)
              .toList().size(),equalTo(5));
 
 

Specified by:

groupedStatefullyUntil in interface Traversable<T>

Parameters:

predicate - Window while true

Returns:

Traversable windowed while predicate holds

combine

default AnyMSeq<W,T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
                             java.util.function.BinaryOperator<T> op)

Description copied from interface: Traversable

Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation. The output of a combination may in turn be combined with it's neighbour

  
  ReactiveSeq.of(1,1,2,3)
                   .combine((a, b)->a.equals(b),Semigroups.intSum)
                   .toListX()
                   
  //ListX(3,4) 
 

Specified by:

combine in interface Traversable<T>

Parameters:

predicate - Test to see if two neighbours should be joined

op - Reducer to combine neighbours

Returns:

Combined / Partially Reduced Traversable

groupedWhile

default AnyMSeq<W,ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)

Description copied from interface: Traversable

Create a Traversable batched by List, where each batch is populated while the predicate holds

  
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .groupedWhile(i->i%3!=0)
              .toList().size(),equalTo(2));
  
 
 

Specified by:

groupedWhile in interface Traversable<T>

Parameters:

predicate - Batch while predicate holds, transform open next batch

Returns:

SequenceM batched into lists determined by the predicate supplied

groupedWhile

default <C extends java.util.Collection<? super T>> AnyMSeq<W,C> groupedWhile(java.util.function.Predicate<? super T> predicate,
                                                                              java.util.function.Supplier<C> factory)

Description copied from interface: Traversable

Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds

  
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .batchWhile(i->i%3!=0)
              .toList()
              .size(),equalTo(2));
 
 

Specified by:

groupedWhile in interface Traversable<T>

Parameters:

predicate - Batch while predicate holds, transform open next batch

factory - Collection factory

Returns:

SequenceM batched into collections determined by the predicate supplied

groupedUntil

default <C extends java.util.Collection<? super T>> AnyMSeq<W,C> groupedUntil(java.util.function.Predicate<? super T> predicate,
                                                                              java.util.function.Supplier<C> factory)

Description copied from interface: Traversable

Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds

  
  ReactiveSeq.of(1,2,3,4,5,6)
             .groupedUntil(i->i%3!=0)
             .toList()
             
  //2
 
 

Specified by:

groupedUntil in interface Traversable<T>

Parameters:

predicate - Batch until predicate holds, transform open next batch

factory - Collection factory

Returns:

SequenceM batched into collections determined by the predicate supplied

grouped

default AnyMSeq<W,ListX<T>> grouped(int groupSize)

Description copied from interface: Traversable

Group elements in a Stream

 
  List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(Collectors.toList());
 
  assertThat(list.get(0), hasItems(1, 2, 3));
  assertThat(list.get(1), hasItems(4, 5, 6));
 
 
 

Specified by:

grouped in interface Traversable<T>

Parameters:

groupSize - Size of each Group

Returns:

Stream with elements grouped by size

grouped

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)

Description copied from interface: Traversable

Group this Traversable by the provided classifying function and collected by the provided Collector

Specified by:

grouped in interface Traversable<T>

Parameters:

classifier - Grouping function

downstream - Collector to create the grouping collection

Returns:

Traversable of grouped data

grouped

default <K> AnyMSeq<W,org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)

Description copied from interface: Traversable

Group this Traversable by the provided classifying function and collected by the provided Collector

Specified by:

grouped in interface Traversable<T>

Parameters:

classifier - Grouping function

Returns:

Traversable of grouped data

takeWhile

default AnyMSeq<W,T> takeWhile(java.util.function.Predicate<? super T> p)

Description copied from interface: Traversable

Generate a new Traversable that takes elements from this Traversable as long as the predicate holds

  
     ListX.of(1,2,3).takeWhile(i<3);
     //[1,2]
 
 

Specified by:

takeWhile in interface Traversable<T>

Parameters:

p - Predicate to determine when values should be taken

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

dropWhile

default AnyMSeq<W,T> dropWhile(java.util.function.Predicate<? super T> p)

Description copied from interface: Traversable

Generate a new Traversable that drops elements from this Traversable as long as the predicate holds

  
     ListX.of(1,2,3).dropWhile(i<3);
     //[3]
 
 

Specified by:

dropWhile in interface Traversable<T>

Parameters:

p - Predicate to determine when values should be dropped

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

takeUntil

default AnyMSeq<W,T> takeUntil(java.util.function.Predicate<? super T> p)

Description copied from interface: Traversable

Generate a new Traversable that takes elements from this Traversable until the predicate holds

  
     ListX.of(1,2,3).takeUntil(i<2);
     //[1,2]
 
 

Specified by:

takeUntil in interface Traversable<T>

Parameters:

p - Predicate to determine when values should be taken until

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

dropUntil

default AnyMSeq<W,T> dropUntil(java.util.function.Predicate<? super T> p)

Description copied from interface: Traversable

Generate a new Traversable that drops elements from this Traversable until the predicate holds

  
     ListX.of(1,2,3).dropUntil(i>2);
     //[3]
 
 

Specified by:

dropUntil in interface Traversable<T>

Parameters:

p - Predicate to determine when values should be dropped

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

dropRight

default AnyMSeq<W,T> dropRight(int num)

Description copied from interface: Traversable

Generate a new Traversable that drops the specified number elements from the take of this Traversable

  
     ListX.of(1,2,3).dropRight(2);
     //[1]
 
 

Specified by:

dropRight in interface Traversable<T>

Parameters:

num - Drop this number of elements from the take of this Traversable

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

takeRight

default AnyMSeq<W,T> takeRight(int num)

Description copied from interface: Traversable

Generate a new Traversable that takes the specified number elements from the take of this Traversable

  
     ListX.of(1,2,3).takeRight(2);
     //[2,3]
 
 

Specified by:

takeRight in interface Traversable<T>

Parameters:

num - Take this number of elements from the take of this Traversable

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

reverse

default AnyMSeq<W,T> reverse()

Description copied from interface: Traversable

Potentially efficient Stream reversal. Is efficient if - Sequence created via a range - Sequence created via a List - Sequence created via an Array / var args Otherwise Sequence collected into a Collection prior to reversal

  assertThat( of(1, 2, 3).reverse().toList(),
 equalTo(asList(3, 2, 1)));  

Specified by:

reverse in interface Traversable<T>

shuffle

default AnyMSeq<W,T> shuffle()

Specified by:

shuffle in interface Traversable<T>

shuffle

default AnyMSeq<W,T> shuffle(java.util.Random random)

Specified by:

shuffle in interface Traversable<T>

distinct

default AnyMSeq<W,T> distinct()

Specified by:

distinct in interface Traversable<T>

scanLeft

default AnyMSeq<W,T> scanLeft(Monoid<T> monoid)

Description copied from interface: Traversable

Scan left using supplied Monoid

   
 
 	assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
 													.scanLeft(Reducers.toString("")).toList());
         
         
 

Specified by:

scanLeft in interface Traversable<T>

Returns:

scanLeft

default <U> AnyMSeq<W,U> scanLeft(U seed,
                                  java.util.function.BiFunction<? super U,? super T,? extends U> function)

Description copied from interface: Traversable

Scan left

  
  assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
         		is(4));
 
 

Specified by:

scanLeft in interface Traversable<T>

scanRight

default AnyMSeq<W,T> scanRight(Monoid<T> monoid)

Description copied from interface: Traversable

Scan right

  
 assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
             is(asList("", "c", "bc", "abc").size()));
 
 

Specified by:

scanRight in interface Traversable<T>

scanRight

default <U> AnyMSeq<W,U> scanRight(U identity,
                                   java.util.function.BiFunction<? super T,? super U,? extends U> combiner)

Description copied from interface: Traversable

Scan right

  
 assertThat(of("a", "ab", "abc").map(str->str.length()).scanRight(0, (t, u) -> u + t).toList().size(),
             is(asList(0, 3, 5, 6).size()));
 
 
 

Specified by:

scanRight in interface Traversable<T>

sorted

default AnyMSeq<W,T> sorted()

Description copied from interface: Traversable

  assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); 
 

Specified by:

sorted in interface Traversable<T>

sorted

default AnyMSeq<W,T> sorted(java.util.Comparator<? super T> c)

Description copied from interface: Traversable

  
 	assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
 
 

Specified by:

sorted in interface Traversable<T>

Parameters:

c - Compartor to sort with

Returns:

Sorted Stream

skip

default AnyMSeq<W,T> skip(long num)

Description copied from interface: Traversable

  assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 

Specified by:

skip in interface Traversable<T>

Parameters:

num - Number of elemenets to skip

Returns:

Stream with specified number of elements skipped

skipWhile

default AnyMSeq<W,T> skipWhile(java.util.function.Predicate<? super T> p)

Description copied from interface: Traversable

SkipWhile drops elements from the Stream while the predicate holds, once the predicte returns true all subsequent elements are included *

 
 assertThat(ReactiveSeq.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
 
 

Specified by:

skipWhile in interface Traversable<T>

Parameters:

p - Predicate to skip while true

Returns:

Stream with elements skipped while predicate holds

skipUntil

default AnyMSeq<W,T> skipUntil(java.util.function.Predicate<? super T> p)

Description copied from interface: Traversable

Drop elements from the Stream until the predicate returns true, after which all elements are included

  assertThat(ReactiveSeq.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
 

Specified by:

skipUntil in interface Traversable<T>

Parameters:

p - Predicate to skip until true

Returns:

Stream with elements skipped until predicate holds

intersperse

default AnyMSeq<W,T> intersperse(T value)

Description copied from interface: Traversable

Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) ReactiveSeq.of(1, 2, 3, 4).intersperse(0)

Specified by:

intersperse in interface Traversable<T>

skipLast

default AnyMSeq<W,T> skipLast(int num)

Description copied from interface: Traversable

assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));

Specified by:

skipLast in interface Traversable<T>

Returns:

slice

default AnyMSeq<W,T> slice(long from,
                           long to)

Specified by:

slice in interface Traversable<T>

sorted

default <U extends java.lang.Comparable<? super U>> AnyMSeq<W,T> sorted(java.util.function.Function<? super T,? extends U> function)

Specified by:

sorted in interface Traversable<T>

permutations

default AnyMSeq<W,ReactiveSeq<T>> permutations()

Description copied from interface: ExtendedTraversable

Generate the permutations based on values in the ExtendedTraversable.

Specified by:

permutations in interface ExtendedTraversable<T>

Returns:

Permutations from this ExtendedTraversable

combinations

default AnyMSeq<W,ReactiveSeq<T>> combinations(int size)

Description copied from interface: ExtendedTraversable

Generate the combinations based on values in the ExtendedTraversable.

 
   ExtendedTraversable<Integer> stream = ReactiveSeq.of(1,2,3);
   stream.combinations(2)
   
   //ReactiveSeq[ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]]
 
 

Specified by:

combinations in interface ExtendedTraversable<T>

Parameters:

size - of combinations

Returns:

All combinations of the elements in this ExtendedTraversable of the specified size

combinations

default AnyMSeq<W,ReactiveSeq<T>> combinations()

Description copied from interface: ExtendedTraversable

Generate the combinations based on values in the ExtendedTraversable.

 
   ReactiveSeq.of(1,2,3).combinations()
   
   //ReactiveSeq[ReactiveSeq[],ReactiveSeq[1],ReactiveSeq[2],ReactiveSeq[3].ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]
   			,ReactiveSeq[1,2,3]]
 
 

Specified by:

combinations in interface ExtendedTraversable<T>

Returns:

All combinations of the elements in this ExtendedTraversable

ofType

default <U> AnyMSeq<W,U> ofType(java.lang.Class<? extends U> type)

Description copied from interface: Filters

Keep only those elements in a stream that are of a given type.

  
 
 // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
 
 
 

Specified by:

ofType in interface Filters<T>

filterNot

default AnyMSeq<W,T> filterNot(java.util.function.Predicate<? super T> fn)

Description copied from interface: Filters

Remove any elements for which the predicate holds (inverse operation to filter) e.g.

  
   
     of(1,2,3).filter(i->i>2);
     
     //[1,2]
   
 
 

Specified by:

filterNot in interface Filters<T>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

unitIterator

default <U> AnyMSeq<W,U> unitIterator(java.util.Iterator<U> U)

Description copied from interface: Traversable

Create an IterableFunctor instance of the same type from an Iterator

 
       ReactiveSeq<Integer> newSeq = seq.unitIterable(myIterator);

 
 

Specified by:

unitIterator in interface AnyM<W extends WitnessType<W>,T>

Specified by:

unitIterator in interface Traversable<T>

Parameters:

U - Iterator to create new IterableFunctor from

Returns:

New IterableFunctor instance

emptyUnit

default <T> AnyMSeq<W,T> emptyUnit()

Specified by:

emptyUnit in interface AnyM<W extends WitnessType<W>,T>

Specified by:

emptyUnit in interface EmptyUnit<T>

Returns:

A new, empty instance of this EmptyUnit type

filter

default AnyMSeq<W,T> filter(java.util.function.Predicate<? super T> p)

Description copied from interface: AnyM

Perform a filter operation on the wrapped monad instance e.g.

 
   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]]
 
 
 
 

Specified by:

filter in interface AnyM<W extends WitnessType<W>,T>

Specified by:

filter in interface FilterableTransformable<T>

Specified by:

filter in interface Filters<T>

Parameters:

p - Filtering predicate

Returns:

Filtered AnyM

map

default <R> AnyMSeq<W,R> map(java.util.function.Function<? super T,? extends R> fn)

Description copied from interface: Transformable

Transform this functor using the supplied transformation function

  
  
  
    of(1,2,3).map(i->i*2)
    
    //[2,4,6]
  
 
 

Specified by:

map in interface AnyM<W extends WitnessType<W>,T>

Specified by:

map in interface FilterableTransformable<T>

Specified by:

map in interface Transformable<T>

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

forEach

default <X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(long numberOfElements,
                                                                                 java.util.function.Consumer<? super T> consumer)

Description copied from interface: ReactiveStreamsTerminalOperations

Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription e.g.

 
     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!
 
 

Specified by:

forEach in interface FoldableTraversable<T>

Specified by:

forEach in interface ReactiveStreamsTerminalOperations<T>

Parameters:

numberOfElements - To consume from the Stream at this time

consumer - To accept incoming events from the Stream

Returns:

Subscription so that further processing can be continued or cancelled.

forEach

default <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)

Description copied from interface: ReactiveStreamsTerminalOperations

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. More elements can be consumed later, by called request on the returned Subscription

 
     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!
 
 

Specified by:

forEach in interface FoldableTraversable<T>

Specified by:

forEach in interface ReactiveStreamsTerminalOperations<T>

Parameters:

numberOfElements - To consume from the Stream at this time

consumer - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

Returns:

Subscription so that further processing can be continued or cancelled.

forEach

default <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)

Description copied from interface: ReactiveStreamsTerminalOperations

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. More elements can be consumed later, by called request on the returned Subscription, when the entire Stream has been processed an onComplete event will be recieved.

 
     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!
 
 

Specified by:

forEach in interface FoldableTraversable<T>

Specified by:

forEach in interface ReactiveStreamsTerminalOperations<T>

Parameters:

numberOfElements - To consume from the Stream at this time

consumer - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

onComplete - To run after an onComplete event

Returns:

Subscription so that further processing can be continued or cancelled.

forEach

default <X extends java.lang.Throwable> void forEach(java.util.function.Consumer<? super T> consumerElement,
                                                     java.util.function.Consumer<? super java.lang.Throwable> consumerError)

Description copied from interface: ReactiveStreamsTerminalOperations

Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,

 
     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!
     
 
 

Specified by:

forEach in interface FoldableTraversable<T>

Specified by:

forEach in interface ReactiveStreamsTerminalOperations<T>

Parameters:

consumerElement - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

forEach

default <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)

Description copied from interface: ReactiveStreamsTerminalOperations

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.

 
     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!
     
     
 
 

Specified by:

forEach in interface FoldableTraversable<T>

Specified by:

forEach in interface ReactiveStreamsTerminalOperations<T>

Parameters:

consumerElement - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

onComplete - To run after an onComplete event

peek

default AnyMSeq<W,T> peek(java.util.function.Consumer<? super T> c)

Description copied from interface: AnyM

Perform a peek operation on the wrapped monad e.g.

  
   AnyM.fromCompletableFuture(CompletableFuture.supplyAsync(()->loadData())
       .peek(System.out::println)
 
 

Specified by:

peek in interface AnyM<W extends WitnessType<W>,T>

Specified by:

peek in interface Transformable<T>

Parameters:

c - Consumer to accept current data

Returns:

AnyM after peek operation

flatten

static <W extends WitnessType<W>,T1> AnyMSeq<W,T1> flatten(AnyMSeq<W,AnyMSeq<W,T1>> nested)

aggregate

default AnyMSeq<W,java.util.List<T>> aggregate(AnyM<W,T> next)

Description copied from interface: AnyM

Aggregate the contents of this Monad and the supplied Monad

 
 
 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)));
    	

Specified by:

aggregate in interface AnyM<W extends WitnessType<W>,T>

Parameters:

next - Monad to aggregate content with

Returns:

Aggregated Monad

flatMapA

default <R> AnyMSeq<W,R> flatMapA(java.util.function.Function<? super T,? extends AnyM<W,? extends R>> fn)

Specified by:

flatMapA in interface AnyM<W extends WitnessType<W>,T>

retry

default <R> AnyMSeq<W,R> retry(java.util.function.Function<? super T,? extends R> fn)

Description copied from interface: Transformable

Retry a transformation if it fails. Default settings are to retry up to 7 times, with an doubling backoff period starting @ 2 seconds delay before retry.

 
 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
 
 

Specified by:

retry in interface AnyM<W extends WitnessType<W>,T>

Specified by:

retry in interface Transformable<T>

Parameters:

fn - Function to retry if fails

retry

default <R> AnyMSeq<W,R> retry(java.util.function.Function<? super T,? extends R> fn,
                               int retries,
                               long delay,
                               java.util.concurrent.TimeUnit timeUnit)

Description copied from interface: Transformable

Retry a transformation if it fails. Retries up to retries times, with an doubling backoff period starting @ delay TimeUnits delay before retry.

 
 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
 
 

Specified by:

retry in interface AnyM<W extends WitnessType<W>,T>

Specified by:

retry in interface Transformable<T>

Parameters:

fn - Function to retry if fails

retries - Number of retries

delay - Delay in TimeUnits

timeUnit - TimeUnit to use for delay

prependS

default AnyMSeq<W,T> prependS(java.util.stream.Stream<? extends T> stream)

Description copied from interface: Traversable

Prepend Stream to this ReactiveSeq

 
  List<String> result = ReactiveSeq.of(1, 2, 3)
                                   .prependS(of(100, 200, 300))
                                   .map(it -> it + "!!")
                                   .collect(Collectors.toList());

  assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
 
 

Specified by:

prependS in interface Traversable<T>

Parameters:

stream - to Prepend

Returns:

ReactiveSeq with Stream prepended

append

default AnyMSeq<W,T> append(T... values)

Description copied from interface: Traversable

Append values to the take of this ReactiveSeq

 
  List<String> result = ReactiveSeq.of(1, 2, 3).append(100, 200, 300).map(it -> it + "!!").collect(Collectors.toList());

  assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!")));     * 
 

Specified by:

append in interface Traversable<T>

Parameters:

values - to append

Returns:

ReactiveSeq with appended values

append

default AnyMSeq<W,T> append(T value)

Specified by:

append in interface Traversable<T>

prepend

default AnyMSeq<W,T> prepend(T value)

Specified by:

prepend in interface Traversable<T>

prepend

default AnyMSeq<W,T> prepend(T... values)

Description copied from interface: Traversable

Prepend given values to the skip of the Stream

 
 List<String> result = 	ReactiveSeq.of(1,2,3)
 									 .prepend(100,200,300)
 										 .map(it ->it+"!!")
 										 .collect(Collectors.toList());

 			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 

Specified by:

prepend in interface Traversable<T>

Parameters:

values - to prepend

Returns:

ReactiveSeq with values prepended

insertAt

default AnyMSeq<W,T> insertAt(int pos,
                              T... values)

Description copied from interface: Traversable

Insert data into a stream at given position

 
  List<String> result = ReactiveSeq.of(1, 2, 3).insertAt(1, 100, 200, 300).map(it -> it + "!!").collect(Collectors.toList());

  assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));     *
 
 

Specified by:

insertAt in interface Traversable<T>

Parameters:

pos - to insert data at

values - to insert

Returns:

Stream with new data inserted

deleteBetween

default AnyMSeq<W,T> deleteBetween(int start,
                                   int end)

Description copied from interface: Traversable

Delete elements between given indexes in a Stream

 
  List<String> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).deleteBetween(2, 4).map(it -> it + "!!").collect(Collectors.toList());

  assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "5!!", "6!!")));     * 
 

Specified by:

deleteBetween in interface Traversable<T>

Parameters:

start - index

end - index

Returns:

Stream with elements removed

insertAtS

default AnyMSeq<W,T> insertAtS(int pos,
                               java.util.stream.Stream<T> stream)

Description copied from interface: Traversable

Insert a Stream into the middle of this stream at the specified position

 
  List<String> result = ReactiveSeq.of(1, 2, 3).insertAtS(1, of(100, 200, 300)).map(it -> it + "!!").collect(Collectors.toList());

  assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
 
 

Specified by:

insertAtS in interface Traversable<T>

Parameters:

pos - to insert Stream at

stream - to insert

Returns:

newly conjoined Traversable

recover

default AnyMSeq<W,T> recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)

Description copied from interface: Traversable

Recover from an exception with an alternative value

 
 assertThat(ReactiveSeq.of(1,2,3,4)
 						   .map(i->i+2)
 						   .map(u->{throw new RuntimeException();})
 						   .recover(e->"hello")
 						   .firstValue(),equalTo("hello"));
 
 

Specified by:

recover in interface Traversable<T>

Parameters:

fn - Function that accepts a Throwable and returns an alternative value

Returns:

ReactiveSeq that can recover from an Exception

recover

default <EX extends java.lang.Throwable> AnyMSeq<W,T> recover(java.lang.Class<EX> exceptionClass,
                                                              java.util.function.Function<? super EX,? extends T> fn)

Description copied from interface: Traversable

Recover from a particular exception type

 
 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"));

 
 

Specified by:

recover in interface Traversable<T>

Parameters:

exceptionClass - Type to recover from

fn - That accepts an error and returns an alternative value

Returns:

Traversable that can recover from a particular exception

unit

default <T> AnyMSeq<W,T> unit(T value)

Description copied from interface: AnyM

Construct a new instanceof AnyM using the type of the underlying wrapped monad

 
   AnyM<Integer> ints = AnyM.fromList(Arrays.asList(1,2,3);
   AnyM<String> string = ints.unit("hello");
 
 

Specified by:

unit in interface AnyM<W extends WitnessType<W>,T>

Specified by:

unit in interface Unit<T>

Parameters:

value - to embed inside the monad wrapped by AnyM

Returns:

Newly instantated AnyM

empty

default <T> AnyMSeq<W,T> empty()

Description copied from interface: AnyM

Construct an AnyM wrapping a new empty instance of the wrapped type e.g.

  
 Any<Integer> ints = AnyM.fromStream(Stream.of(1,2,3));
 AnyM<Integer> empty=ints.empty();
 
 

Specified by:

empty in interface AnyM<W extends WitnessType<W>,T>

Returns:

Empty AnyM

flatMap

default <R> AnyMSeq<W,R> flatMap(java.util.function.Function<? super T,? extends AnyM<W,? extends R>> fn)

stream

ReactiveSeq<T> stream()

Specified by:

stream in interface AnyM<W extends WitnessType<W>,T>

Specified by:

stream in interface ConvertableSequence<T>

Specified by:

stream in interface ExtendedTraversable<T>

Specified by:

stream in interface FoldableTraversable<T>

Specified by:

stream in interface Sequential<T>

Specified by:

stream in interface ToStream<T>

Specified by:

stream in interface TransformerTraversable<T>

Specified by:

stream in interface Traversable<T>

Returns:

ReactiveSeq from this Streamable

toDequeX

default DequeX<T> toDequeX()

Specified by:

toDequeX in interface ConvertableSequence<T>

toQueueX

default QueueX<T> toQueueX()

Specified by:

toQueueX in interface ConvertableSequence<T>

toSetX

default SetX<T> toSetX()

Specified by:

toSetX in interface ConvertableSequence<T>

toListX

default ListX<T> toListX()

Specified by:

toListX in interface ConvertableSequence<T>

toPStackX

default PStackX<T> toPStackX()

Specified by:

toPStackX in interface ConvertableSequence<T>

toPVectorX

default PVectorX<T> toPVectorX()

Specified by:

toPVectorX in interface ConvertableSequence<T>

toPQueueX

default PQueueX<T> toPQueueX()

Specified by:

toPQueueX in interface ConvertableSequence<T>

toPBagX

default PBagX<T> toPBagX()

Specified by:

toPBagX in interface ConvertableSequence<T>

toPSetX

default PSetX<T> toPSetX()

Specified by:

toPSetX in interface ConvertableSequence<T>

toPOrderedSetX

default POrderedSetX<T> toPOrderedSetX()

Specified by:

toPOrderedSetX in interface ConvertableSequence<T>