com.aol.cyclops.types.anyM

Interface AnyMSeq<T>

All Superinterfaces:

AnyM<T>, org.jooq.lambda.Collectable<T>, ConvertableSequence<T>, ConvertableToReactiveSeq<T>, CyclopsCollectable<T>, EmptyUnit<T>, ExtendedTraversable<T>, Filterable<T>, FilterableFunctor<T>, FlatMap<T>, Foldable<T>, Functor<T>, java.lang.Iterable<T>, IterableCollectable<T>, IterableFunctor<T>, org.reactivestreams.Publisher<T>, Sequential<T>, ToStream<T>, Traversable<T>, Unit<T>, Unwrapable, ZippingApplicativable<T>

All Known Implementing Classes:

AnyMSeqImpl

public interface AnyMSeq<T>
extends AnyM<T>, ConvertableSequence<T>, ExtendedTraversable<T>, Sequential<T>, CyclopsCollectable<T>, IterableCollectable<T>, FilterableFunctor<T>, ZippingApplicativable<T>, org.reactivestreams.Publisher<T>

Nested Class Summary

Nested classes/interfaces inherited from interface com.aol.cyclops.control.AnyM

AnyM.AnyMFactory

Method Summary

Modifier and Type	Method and Description
AnyMSeq<java.util.List<T>>	aggregate(AnyM<T> next) Aggregate the contents of this Monad and the supplied Monad
default <R> ZippingApplicativable<R>	ap1(java.util.function.Function<? super T,? extends R> fn)
default <R> ApplyingZippingApplicativeBuilder<T,R,ZippingApplicativable<R>>	applicatives()
<R> AnyMSeq<R>	applyM(AnyM<java.util.function.Function<? super T,? extends R>> fn) Apply function/s inside supplied Monad to data in current Monad e.g.
<R> AnyMSeq<R>	bind(java.util.function.Function<? super T,?> fn) Perform a looser typed flatMap / bind operation The return type can be another type other than the host type Note the modified javaslang monad laws are not applied during the looser typed bind operation The modification being used to work around the limits of the Java type system.
default <U> AnyMSeq<U>	cast(java.lang.Class<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
default org.jooq.lambda.Collectable<T>	collectable() Narrow this class to a Collectable
default AnyMSeq<ReactiveSeq<T>>	combinations() ReactiveSeq.of(1,2,3).combinations() //SequenceM[SequenceM[],SequenceM[1],SequenceM[2],SequenceM[3].SequenceM[1,2],SequenceM[1,3],SequenceM[2,3] ,SequenceM[1,2,3]]
default AnyMSeq<ReactiveSeq<T>>	combinations(int size) ReactiveSeq.of(1,2,3).combinations(2) //SequenceM[SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]]
default AnyMSeq<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 & reduction operation.
default AnyMSeq<T>	cycle(int times) Convert to a Stream with the values repeated specified times
default AnyMSeq<T>	cycle(Monoid<T> m, int times) Convert to a Stream with the result of a reduction operation repeated specified times
default AnyMSeq<T>	cycleUntil(java.util.function.Predicate<? super T> predicate) Repeat in a Stream until specified predicate holds
default AnyMSeq<T>	cycleWhile(java.util.function.Predicate<? super T> predicate) Repeat in a Stream while specified predicate holds
default AnyMSeq<T>	distinct()
default AnyMSeq<T>	dropRight(int num)
default AnyMSeq<T>	dropUntil(java.util.function.Predicate<? super T> p)
default AnyMSeq<T>	dropWhile(java.util.function.Predicate<? super T> p)
<T> AnyMSeq<T>	empty() Construct an AnyM wrapping an empty instance of the wrapped type e.g.
<T> AnyMSeq<T>	emptyUnit()
AnyMSeq<T>	filter(java.util.function.Predicate<? super T> p) Perform a filter operation on the wrapped monad instance e.g.
default AnyMSeq<T>	filterNot(java.util.function.Predicate<? super T> fn)
<R> AnyMSeq<R>	flatMap(java.util.function.Function<? super T,? extends AnyM<? extends R>> fn) flatMap operation AnyM follows the javaslang modified 'monad' laws https://gist.github.com/danieldietrich/71be006b355d6fbc0584 In particular left-identity becomes Left identity: unit(a).flatMap(f) ≡ select(f.apply(a)) Or in plain English, if your flatMap function returns multiple values (such as flatMap by Stream) but the current Monad only can only hold one value, only the first value is accepted.
<T1> AnyMSeq<T1>	flatten() join / flatten one level of a nested hierarchy
<R1,R> AnyMSeq<R>	forEach2(java.util.function.Function<? super T,? extends AnyM<R1>> monad, java.util.function.Function<? super T,java.util.function.Function<? 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)
<R1,R> AnyMSeq<R>	forEach2(java.util.function.Function<? super T,? extends AnyM<R1>> monad, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? 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)
<R1,R2,R> AnyMSeq<R>	forEach3(java.util.function.Function<? super T,? extends AnyM<R1>> monad1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyM<R2>>> monad2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction) Perform a three level nested internal iteration over this AnyM and the supplied monads
<R1,R2,R> AnyMSeq<R>	forEach3(java.util.function.Function<? super T,? extends AnyM<R1>> monad1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyM<R2>>> monad2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction) Perform a three level nested internal iteration over this Stream and the supplied streams
default <K> AnyMSeq<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>>	grouped(java.util.function.Function<? super T,? extends K> classifier)
default <K,A,D> AnyMSeq<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)
default AnyMSeq<ListX<T>>	grouped(int groupSize) Group elements in a Stream
default <C extends java.util.Collection<? super T>> AnyMSeq<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<ListX<T>>	groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate) Create SequenceM of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied bipredicate holds.
default AnyMSeq<ListX<T>>	groupedUntil(java.util.function.Predicate<? super T> predicate) Create a SequenceM batched by List, where each batch is populated until the predicate holds
default <C extends java.util.Collection<? super T>> AnyMSeq<C>	groupedUntil(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 until the predicate holds
default AnyMSeq<ListX<T>>	groupedWhile(java.util.function.Predicate<? super T> predicate) Create a SequenceM batched by List, where each batch is populated while the predicate holds
default <C extends java.util.Collection<? super T>> AnyMSeq<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<T>	intersperse(T value) Returns a stream with a given value interspersed between any two values of this stream.
static <U,R> java.util.function.Function<AnyMSeq<U>,AnyMSeq<R>>	liftM(java.util.function.Function<? super U,? extends R> fn) Lift a function so it accepts an AnyM and returns an AnyM (any monad) AnyM view simplifies type related challenges.
static <U1,U2,R> java.util.function.BiFunction<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<R>>	liftM2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn) Lift a function so it accepts a Monad and returns a Monad (simplex view of a wrapped Monad) AnyM view simplifies type related challenges.
static <U1,U2,R> java.util.function.Function<AnyMSeq<U1>,java.util.function.Function<AnyMSeq<U2>,AnyMSeq<R>>>	liftM2(java.util.function.Function<U1,java.util.function.Function<U2,R>> fn) Lift a Curried Function into Monadic form
static <U1,U2,U3,R> java.util.function.Function<AnyMSeq<U1>,java.util.function.Function<AnyMSeq<U2>,java.util.function.Function<AnyMSeq<U3>,AnyMSeq<R>>>>	liftM3(java.util.function.Function<? super U1,java.util.function.Function<? super U2,java.util.function.Function<? super U3,? extends R>>> fn) Lift a Curried Function into Monadic form
static <U1,U2,U3,R> org.jooq.lambda.function.Function3<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<R>>	liftM3(org.jooq.lambda.function.Function3<? super U1,? super U2,? super U3,? extends R> fn) Lift a jOOλ Function3 into Monadic form.
static <U1,U2,U3,R> TriFunction<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<R>>	liftM3Cyclops(TriFunction<? super U1,? super U2,? super U3,? extends R> fn) Lift a TriFunction into Monadic form.
static <U1,U2,U3,U4,R> java.util.function.Function<AnyMSeq<U1>,java.util.function.Function<AnyMSeq<U2>,java.util.function.Function<AnyMSeq<U3>,java.util.function.Function<AnyMSeq<U4>,AnyMSeq<R>>>>>	liftM4(java.util.function.Function<? super U1,java.util.function.Function<? super U2,java.util.function.Function<? super U3,java.util.function.Function<? super U4,? extends R>>>> fn) Lift a Curried Function into Monadic form
static <U1,U2,U3,U4,R> org.jooq.lambda.function.Function4<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<U4>,AnyMSeq<R>>	liftM4(org.jooq.lambda.function.Function4<? super U1,? super U2,? super U3,? super U4,? extends R> fn) Lift a jOOλ Function4 into Monadic form.
static <U1,U2,U3,U4,R> QuadFunction<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<U4>,AnyMSeq<R>>	liftM4Cyclops(QuadFunction<? super U1,? super U2,? super U3,? super U4,? extends R> fn) Lift a QuadFunction into Monadic form.
static <U1,U2,U3,U4,U5,R> java.util.function.Function<AnyMSeq<U1>,java.util.function.Function<AnyMSeq<U2>,java.util.function.Function<AnyMSeq<U3>,java.util.function.Function<AnyMSeq<U4>,java.util.function.Function<AnyMSeq<U5>,AnyMSeq<R>>>>>>	liftM5(java.util.function.Function<? super U1,java.util.function.Function<? super U2,java.util.function.Function<? super U3,java.util.function.Function<? super U4,java.util.function.Function<? super U5,? extends R>>>>> fn) Lift a Curried Function (5 levels a->b->c->d->e->fn.apply(a,b,c,d,e) ) into Monadic form
static <U1,U2,U3,U4,U5,R> org.jooq.lambda.function.Function5<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<U4>,AnyMSeq<U5>,AnyMSeq<R>>	liftM5(org.jooq.lambda.function.Function5<? super U1,? super U2,? super U3,? super U4,? super U5,? extends R> fn) Lift a jOOλ Function5 (5 parameters) into Monadic form
static <U1,U2,U3,U4,U5,R> QuintFunction<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<U4>,AnyMSeq<U5>,AnyMSeq<R>>	liftM5Cyclops(QuintFunction<? super U1,? super U2,? super U3,? super U4,? super U5,? extends R> fn) Lift a QuintFunction (5 parameters) into Monadic form
<R> AnyMSeq<R>	map(java.util.function.Function<? super T,? extends R> fn) Perform a map operation on the wrapped monad instance e.g.
default <U> AnyMSeq<U>	ofType(java.lang.Class<U> type) Keep only those elements in a stream that are of a given type.
default <R> AnyMSeq<R>	patternMatch(java.util.function.Function<Matchable.CheckValues<T,R>,Matchable.CheckValues<T,R>> case1, java.util.function.Supplier<? extends R> otherwise) Transform the elements of this Stream with a Pattern Matching case and default value
default AnyMSeq<T>	peek(java.util.function.Consumer<? super T> c) Perform a peek operation on the wrapped monad e.g.
default AnyMSeq<ReactiveSeq<T>>	permutations() Generate the permutations based on values in the SequenceM Makes use of Streamable to store intermediate stages in a collection
AnyMSeq<T>	replicateM(int times)
default AnyMSeq<T>	reverse()
default AnyMSeq<T>	scanLeft(Monoid<T> monoid) Scan left using supplied Monoid
default <U> AnyMSeq<U>	scanLeft(U seed, java.util.function.BiFunction<U,? super T,U> function) Scan left
default AnyMSeq<T>	scanRight(Monoid<T> monoid) Scan right
default <U> AnyMSeq<U>	scanRight(U identity, java.util.function.BiFunction<? super T,U,U> combiner) Scan right
static <T1> AnyMSeq<ListX<T1>>	sequence(java.util.Collection<? extends AnyMSeq<T1>> seq) Convert a Collection of Monads to a Monad with a List
static <T1> AnyMSeq<ListX<T1>>	sequence(java.util.stream.Stream<? extends AnyMSeq<T1>> seq) Convert a Stream of Monads to a Monad with a List
default AnyMSeq<T>	shuffle()
default AnyMSeq<T>	shuffle(java.util.Random random)
default AnyMSeq<T>	skip(long num) assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));
default AnyMSeq<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<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<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<T>	slice(long from, long to)
default AnyMSeq<ListX<T>>	sliding(int windowSize) Create a sliding view over this Sequence
default AnyMSeq<ListX<T>>	sliding(int windowSize, int increment) Create a sliding view over this Sequence
default AnyMSeq<T>	sorted() assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));
default AnyMSeq<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<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<T>	takeRight(int num)
default AnyMSeq<T>	takeUntil(java.util.function.Predicate<? super T> p)
default AnyMSeq<T>	takeWhile(java.util.function.Predicate<? super T> p)
default Value<T>	toFirstValue()
default Xor<?,ListX<T>>	toXor()
default Xor<ListX<T>,?>	toXorSecondary()
default <R> AnyMSeq<R>	trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper) Performs a map operation that can call a recursive method without running out of stack space
static <T,R> AnyMSeq<ListX<R>>	traverse(java.util.Collection<? extends AnyMSeq<T>> seq, java.util.function.Function<? super T,? extends R> fn) Convert a Stream of Monads to a Monad with a List applying the supplied function in the process
<T> AnyMSeq<T>	unit(T value) Construct a new instanceof AnyM using the type of the underlying wrapped monad
<R> R	unwrap()
default <U,R> AnyMSeq<R>	zip(java.lang.Iterable<U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
default <U> AnyMSeq<org.jooq.lambda.tuple.Tuple2<T,U>>	zip(org.jooq.lambda.Seq<U> other) Zip 2 streams into one
default <S,U> AnyMSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>>	zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends U> third) zip 3 Streams into one
default <T2,T3,T4> AnyMSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>	zip4(java.util.stream.Stream<T2> second, java.util.stream.Stream<T3> third, java.util.stream.Stream<T4> fourth) zip 4 Streams into 1
default <U> AnyMSeq<org.jooq.lambda.tuple.Tuple2<T,U>>	zipStream(java.util.stream.Stream<U> other) Zip 2 streams into one
default AnyMSeq<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>	zipWithIndex() Add an index to the current Stream

Methods inherited from interface com.aol.cyclops.control.AnyM

fromArray, fromCollection, fromCompletableFuture, fromDoubleStream, fromEval, fromFeatureToggle, fromFile, fromFutureW, fromIntStream, fromIor, fromIterable, fromList, fromLongStream, fromMaybe, fromOptional, fromOptionalDouble, fromOptionalInt, fromOptionalLong, fromRange, fromRangeLong, fromSet, fromStream, fromStreamable, fromTry, fromURL, fromXor, listFromCollection, listFromCompletableFuture, listFromEval, listFromFutureW, listFromIor, listFromIterable, listFromIterator, listFromMaybe, listFromOptional, listFromStream, listFromStreamable, listFromXor, matchable, ofConvertableSeq, ofConvertableValue, ofNullable, ofSeq, ofValue, reduceMSeq, reduceMValue, sequence, sequence, streamOf, toSequence, toString, traverse, traverse

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

getStreamable, isEmpty, iterator, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream

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

fixedDelay, onePer, xPer

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

allMatch, anyMatch, avg, avg, avgDouble, avgInt, avgLong, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, max, max, max, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, min, minBy, minBy, mode, noneMatch, percentile, percentile, percentileBy, percentileBy, sum, sum, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toSet, toSet, toString, toString

Methods inherited from interface org.jooq.lambda.Collectable

collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect

Methods inherited from interface com.aol.cyclops.types.IterableCollectable

xMatch

Methods inherited from interface com.aol.cyclops.types.Filterable

notNull

Methods inherited from interface com.aol.cyclops.types.applicative.zipping.ZippingApplicativable

ap2, ap3, ap4, ap5

Methods inherited from interface com.aol.cyclops.types.IterableFunctor

flatMapPublisher, flatMapPublisher, flatMapPublisher, mergePublisher, mergePublisher, unitIterator

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

endsWith, endsWithIterable, findAny, findFirst, firstValue, futureOperations, get, groupBy, headAndTail, join, join, join, lazyOperations, limit, limitLast, limitUntil, limitWhile, onEmpty, onEmptyGet, onEmptyThrow, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, visit, visit

Method Detail

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

Specified by:

collect in interface AnyM<T>

Specified by:

collect in interface org.jooq.lambda.Collectable<T>

Specified by:

collect in interface CyclopsCollectable<T>

applicatives

default <R> ApplyingZippingApplicativeBuilder<T,R,ZippingApplicativable<R>> applicatives()

Specified by:

applicatives in interface ZippingApplicativable<T>

ap1

default <R> ZippingApplicativable<R> ap1(java.util.function.Function<? super T,? extends R> fn)

Specified by:

ap1 in interface ZippingApplicativable<T>

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>

collectable

default org.jooq.lambda.Collectable<T> collectable()

Description copied from interface: CyclopsCollectable

Narrow this class to a Collectable

Specified by:

collectable in interface CyclopsCollectable<T>

Specified by:

collectable in interface IterableFunctor<T>

Returns:

Collectable

toFirstValue

default Value<T> toFirstValue()

toXor

default Xor<?,ListX<T>> toXor()

Specified by:

toXor in interface ConvertableSequence<T>

toXorSecondary

default Xor<ListX<T>,?> toXorSecondary()

Specified by:

toXorSecondary in interface ConvertableSequence<T>

cast

default <U> AnyMSeq<U> cast(java.lang.Class<U> type)

Description copied from interface: Functor

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 Functor<T>

trampoline

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

Description copied from interface: Functor

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 Functor<T>

Returns:

patternMatch

default <R> AnyMSeq<R> patternMatch(java.util.function.Function<Matchable.CheckValues<T,R>,Matchable.CheckValues<T,R>> case1,
                                    java.util.function.Supplier<? extends R> otherwise)

Description copied from interface: Functor

Transform the elements of this Stream with a Pattern Matching case and default value

 
 List<String> result = CollectionX.of(1,2,3,4)
                                              .patternMatch(
                                                        c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
                                                      )
 
 // CollectionX["odd","even","odd","even"]
 

Specified by:

patternMatch in interface Functor<T>

Parameters:

case1 - Function to generate a case (or chain of cases as a single case)

otherwise - Value if supplied case doesn't match

Returns:

CollectionX where elements are transformed by pattern matching

cycle

default AnyMSeq<T> cycle(int 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<T> cycle(Monoid<T> m,
                         int 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<T> cycleWhile(java.util.function.Predicate<? super T> predicate)

Description copied from interface: Traversable

Repeat in a Stream while specified predicate holds

 {
        @code
        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

cycleUntil

default AnyMSeq<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<R> zip(java.lang.Iterable<U> other,
                             java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Specified by:

zip in interface Traversable<T>

zipStream

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

Description copied from interface: Traversable

Zip 2 streams into one

 {
        @code
        List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
        // [[1,"a"],[2,"b"]]
 }
 

Specified by:

zipStream in interface Traversable<T>

zip

default <U> AnyMSeq<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<U> other)

Description copied from interface: Traversable

Zip 2 streams into one

 {
        @code
        List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
        // [[1,"a"],[2,"b"]]
 }
 

Specified by:

zip in interface Traversable<T>

zip3

default <S,U> AnyMSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second,
                                                                java.util.stream.Stream<? extends U> third)

Description copied from interface: Traversable

zip 3 Streams into one

 {
        @code
        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 Traversable<T>

zip4

default <T2,T3,T4> AnyMSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<T2> second,
                                                                          java.util.stream.Stream<T3> third,
                                                                          java.util.stream.Stream<T4> fourth)

Description copied from interface: Traversable

zip 4 Streams into 1

 {
        @code
        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 Traversable<T>

zipWithIndex

default AnyMSeq<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<ListX<T>> sliding(int windowSize)

Description copied from interface: Traversable

Create a sliding view over this Sequence

 {
        @code
        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<ListX<T>> sliding(int windowSize,
                                  int increment)

Description copied from interface: Traversable

Create a sliding view over this Sequence

 {
        @code
        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<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<ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)

Description copied from interface: Traversable

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

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

Specified by:

groupedUntil in interface Traversable<T>

Parameters:

predicate - Batch until predicate holds, then open next batch

Returns:

SequenceM batched into lists determined by the predicate supplied

groupedStatefullyWhile

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

Description copied from interface: Traversable

Create SequenceM of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied bipredicate holds. The bipredicate recieves the Streamable 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)
              .windowStatefullyWhile((s,i)->s.sequenceM().toList().contains(4) ? true : false)
              .toList().size(),equalTo(5));
 
 

Specified by:

groupedStatefullyWhile in interface Traversable<T>

Parameters:

predicate - Window while true

Returns:

SequenceM windowed while predicate holds

combine

default AnyMSeq<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 & 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<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)

Description copied from interface: Traversable

Create a SequenceM batched by List, 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, then open next batch

Returns:

SequenceM batched into lists determined by the predicate supplied

groupedWhile

default <C extends java.util.Collection<? super T>> AnyMSeq<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, then 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<C> groupedUntil(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 until the predicate holds

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

Specified by:

groupedUntil in interface Traversable<T>

Parameters:

predicate - Batch until predicate holds, then open next batch

factory - Collection factory

Returns:

SequenceM batched into collections determined by the predicate supplied

grouped

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

Description copied from interface: Traversable

Group elements in a Stream

 {
        @code
        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<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)

Specified by:

grouped in interface Traversable<T>

grouped

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

Specified by:

grouped in interface Traversable<T>

takeWhile

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

Specified by:

takeWhile in interface Traversable<T>

dropWhile

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

Specified by:

dropWhile in interface Traversable<T>

takeUntil

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

Specified by:

takeUntil in interface Traversable<T>

dropUntil

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

Specified by:

dropUntil in interface Traversable<T>

dropRight

default AnyMSeq<T> dropRight(int num)

Specified by:

dropRight in interface Traversable<T>

takeRight

default AnyMSeq<T> takeRight(int num)

Specified by:

takeRight in interface Traversable<T>

reverse

default AnyMSeq<T> reverse()

Specified by:

reverse in interface Traversable<T>

shuffle

default AnyMSeq<T> shuffle()

Specified by:

shuffle in interface Traversable<T>

shuffle

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

Specified by:

shuffle in interface Traversable<T>

distinct

default AnyMSeq<T> distinct()

Specified by:

distinct in interface Traversable<T>

scanLeft

default AnyMSeq<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<U> scanLeft(U seed,
                                java.util.function.BiFunction<U,? super T,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<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<U> scanRight(U identity,
                                 java.util.function.BiFunction<? super T,U,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<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<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<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<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<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<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<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<T> slice(long from,
                         long to)

Specified by:

slice in interface Traversable<T>

sorted

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

Specified by:

sorted in interface Traversable<T>

permutations

default AnyMSeq<ReactiveSeq<T>> permutations()

Description copied from interface: ExtendedTraversable

Generate the permutations based on values in the SequenceM Makes use of Streamable to store intermediate stages in a collection

Specified by:

permutations in interface ExtendedTraversable<T>

Returns:

Permutations from this SequenceM

combinations

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

Description copied from interface: ExtendedTraversable

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

Specified by:

combinations in interface ExtendedTraversable<T>

Parameters:

size - of combinations

Returns:

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

combinations

default AnyMSeq<ReactiveSeq<T>> combinations()

Description copied from interface: ExtendedTraversable

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

Specified by:

combinations in interface ExtendedTraversable<T>

Returns:

All combinations of the elements in this stream

ofType

default <U> AnyMSeq<U> ofType(java.lang.Class<U> type)

Description copied from interface: Filterable

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 Filterable<T>

filterNot

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

Specified by:

filterNot in interface Filterable<T>

emptyUnit

<T> AnyMSeq<T> emptyUnit()

Specified by:

emptyUnit in interface EmptyUnit<T>

stream

ReactiveSeq<T> stream()

Specified by:

stream in interface AnyM<T>

Specified by:

stream in interface ConvertableSequence<T>

Specified by:

stream in interface Foldable<T>

Specified by:

stream in interface IterableCollectable<T>

Specified by:

stream in interface IterableFunctor<T>

Specified by:

stream in interface ToStream<T>

Specified by:

stream in interface Traversable<T>

Returns:

SequenceM from this Streamable

unwrap

<R> R unwrap()

Specified by:

unwrap in interface AnyM<T>

Specified by:

unwrap in interface Unwrapable

filter

AnyMSeq<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<T>

Specified by:

filter in interface Filterable<T>

Specified by:

filter in interface FilterableFunctor<T>

Parameters:

p - Filtering predicate

Returns:

Filtered AnyM

map

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

Description copied from interface: AnyM

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

  
   AnyM.fromIterable(Try.runWithCatch(this::loadData))
   	 .map(data->transform(data))		
   
   AnyM.fromStream(Stream.of(1,2,3))
       .map(i->i+2);
   
   AnyM[Stream[3,4,5]]
 
 

Specified by:

map in interface AnyM<T>

Specified by:

map in interface FilterableFunctor<T>

Specified by:

map in interface Functor<T>

Specified by:

map in interface IterableFunctor<T>

peek

default AnyMSeq<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<T>

Specified by:

peek in interface Functor<T>

Parameters:

c - Consumer to accept current data

Returns:

AnyM after peek operation

flatten

<T1> AnyMSeq<T1> flatten()

Description copied from interface: AnyM

join / flatten one level of a nested hierarchy

Specified by:

flatten in interface AnyM<T>

Specified by:

flatten in interface FlatMap<T>

Returns:

Flattened / joined one level

aggregate

AnyMSeq<java.util.List<T>> aggregate(AnyM<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(anyM(Optional.of(5)))
 
 AnyM[Stream[List[1,2,3,4,5]]
 
 List<Integer> result = AnyM.fromStream(Stream.of(1,2,3,4))
 							.aggregate(anyM(Optional.of(5)))
 							.toSequence()
                          .flatten()
 							.toList();
		
		assertThat(result,equalTo(Arrays.asList(1,2,3,4,5)));
		

Specified by:

aggregate in interface AnyM<T>

Parameters:

next - Monad to aggregate content with

Returns:

Aggregated Monad

forEach2

<R1,R> AnyMSeq<R> forEach2(java.util.function.Function<? super T,? extends AnyM<R1>> monad,
                           java.util.function.Function<? super T,java.util.function.Function<? 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:

LazyFutureStream with elements generated via nested iteration

forEach2

<R1,R> AnyMSeq<R> forEach2(java.util.function.Function<? super T,? extends AnyM<R1>> monad,
                           java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction,
                           java.util.function.Function<? super T,java.util.function.Function<? 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

<R1,R2,R> AnyMSeq<R> forEach3(java.util.function.Function<? super T,? extends AnyM<R1>> monad1,
                              java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyM<R2>>> monad2,
                              java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction,
                              java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)

Perform a three level nested internal iteration over this Stream and the supplied streams

  
 AnyM.fromArray(1,2)
						.forEach2(a->AnyM.fromIntStream(IntStream.range(10,13)),
						(a->b->AnyM.fromArray(""+(a+b),"hello world"),
									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 monad to flatMap over

stream2 - Nested monad to flatMap 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

forEach3

<R1,R2,R> AnyMSeq<R> forEach3(java.util.function.Function<? super T,? extends AnyM<R1>> monad1,
                              java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyM<R2>>> monad2,
                              java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? 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);
								
 
  //SequenceM[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

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

flatMap

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

flatMap operation AnyM follows the javaslang modified 'monad' laws https://gist.github.com/danieldietrich/71be006b355d6fbc0584 In particular left-identity becomes Left identity: unit(a).flatMap(f) ≡ select(f.apply(a)) Or in plain English, if your flatMap function returns multiple values (such as flatMap by Stream) but the current Monad only can only hold one value, only the first value is accepted. Example 1 : multi-values are supported (AnyM wraps a Stream, List, Set etc)

  
   AnyM<Integer> anyM = AnyM.fromStream(Stream.of(1,2,3)).flatMap(i->AnyM.fromArray(i+1,i+2));
   
   //AnyM[Stream[2,3,3,4,4,5]]
 
 

Example 2 : multi-values are not supported (AnyM wraps a Stream, List, Set etc)

  
   AnyM<Integer> anyM = AnyM.fromOptional(Optional.of(1)).flatMap(i->AnyM.fromArray(i+1,i+2));
   
   //AnyM[Optional[2]]
 
 

Parameters:

fn - flatMap function

Returns:

flatMapped AnyM

applyM

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

Apply function/s inside supplied Monad to data in current Monad e.g. with Streams

 
 
 AnyM<Integer> applied =AnyM.fromStream(Stream.of(1,2,3))
 								.applyM(AnyM.fromStreamable(Streamable.of( (Integer a)->a+1 ,(Integer a) -> a*2)));
		
		 	assertThat(applied.toList(),equalTo(Arrays.asList(2, 2, 3, 4, 4, 6)));
		 

with Optionals

 
  Any<Integer> applied =AnyM.fromOptional(Optional.of(2)).applyM(AnyM.fromOptional(Optional.of( (Integer a)->a+1)) );
			assertThat(applied.toList(),equalTo(Arrays.asList(3)));
                        

Parameters:

fn -

Returns:

unit

<T> AnyMSeq<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<T>

Specified by:

unit in interface Unit<T>

Parameters:

value - to embed inside the monad wrapped by AnyM

Returns:

Newly instantated AnyM

empty

<T> AnyMSeq<T> empty()

Description copied from interface: AnyM

Construct an AnyM wrapping an 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<T>

Returns:

Empty AnyM

replicateM

AnyMSeq<T> replicateM(int times)

bind

<R> AnyMSeq<R> bind(java.util.function.Function<? super T,?> fn)

Description copied from interface: AnyM

Perform a looser typed flatMap / bind operation The return type can be another type other than the host type Note the modified javaslang monad laws are not applied during the looser typed bind operation The modification being used to work around the limits of the Java type system.

  
 AnyM<List<Integer>> m  = AnyM.fromStream(Stream.of(Arrays.asList(1,2,3),Arrays.asList(1,2,3)));
	   AnyM<Integer> intM = m.bind(Collection::stream);
 
 

Specified by:

bind in interface AnyM<T>

Parameters:

fn - flatMap function

Returns:

flatMapped monad

traverse

static <T,R> AnyMSeq<ListX<R>> traverse(java.util.Collection<? extends AnyMSeq<T>> seq,
                                        java.util.function.Function<? super T,? extends R> fn)

Convert a Stream of Monads to a Monad with a List applying the supplied function in the process

 
       Stream<CompletableFuture<Integer>> futures = createFutures();
       AnyMSeq<List<String>> futureList = AnyMonads.traverse(AsAnyMList.anyMList(futures), (Integer i) -> "hello" +i);
        
                

Parameters:

seq - Stream of Monads

fn - Function to apply

Returns:

Monad with a list

sequence

static <T1> AnyMSeq<ListX<T1>> sequence(java.util.Collection<? extends AnyMSeq<T1>> seq)

Convert a Collection of Monads to a Monad with a List

 
		List<CompletableFuture<Integer>> futures = createFutures();
		AnyMSeq<List<Integer>> futureList = AnyMonads.sequence(AsAnyMList.anyMList(futures));

	   //where AnyM wraps  CompletableFuture<List<Integer>>
	  

Parameters:

seq - Collection of monads to convert

Returns:

Monad with a List

See Also:

for helper methods to convert a List of Monads / Collections to List of AnyM

sequence

static <T1> AnyMSeq<ListX<T1>> sequence(java.util.stream.Stream<? extends AnyMSeq<T1>> seq)

Convert a Stream of Monads to a Monad with a List

		Stream<CompletableFuture<Integer>> futures = createFutures();
		AnyMSeq<List<Integer>> futureList = AnyMonads.sequence(AsAnyMList.anyMList(futures));

	   //where AnyM wraps  CompletableFuture<List<Integer>>
	  

Parameters:

seq - Stream of monads to convert

Returns:

Monad with a List

See Also:

for helper methods to convert a List of Monads / Collections to List of AnyM

liftM

static <U,R> java.util.function.Function<AnyMSeq<U>,AnyMSeq<R>> liftM(java.util.function.Function<? super U,? extends R> fn)

Lift a function so it accepts an AnyM and returns an AnyM (any monad) AnyM view simplifies type related challenges.

Specified by:

liftM in interface AnyM<T>

Parameters:

fn -

Returns:

liftM2

static <U1,U2,R> java.util.function.BiFunction<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<R>> liftM2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)

Lift a function so it accepts a Monad and returns a Monad (simplex view of a wrapped Monad) AnyM view simplifies type related challenges. The actual native type is not specified here. e.g.

 	BiFunction<AnyMSeq<Integer>,AnyMSeq<Integer>,AnyMSeq<Integer>> add = Monads.liftM2(this::add);
   
  Optional<Integer> result = add.apply(getBase(),getIncrease());
  
   private Integer add(Integer a, Integer b){
				return a+b;
		}
 

The add method has no null handling, but we can lift the method to Monadic form, and use Optionals to automatically handle null / empty value cases.

Specified by:

liftM2 in interface AnyM<T>

Parameters:

fn - BiFunction to lift

Returns:

Lifted BiFunction

liftM3

static <U1,U2,U3,R> org.jooq.lambda.function.Function3<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<R>> liftM3(org.jooq.lambda.function.Function3<? super U1,? super U2,? super U3,? extends R> fn)

Lift a jOOλ Function3 into Monadic form. A good use case it to take an existing method and lift it so it can accept and return monads

 
 Function3 <AnyMSeq<Double>,AnyMSeq<Entity>,AnyMSeq<String>,AnyMSeq<Integer>> fn = liftM3(this::myMethod);
    
 
 

Now we can execute the Method with Streams, Optional, Futures, Try's etc to transparently inject iteration, null handling, async execution and / or error handling

Specified by:

liftM3 in interface AnyM<T>

Parameters:

fn - Function to lift

Returns:

Lifted function

liftM3Cyclops

static <U1,U2,U3,R> TriFunction<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<R>> liftM3Cyclops(TriFunction<? super U1,? super U2,? super U3,? extends R> fn)

Lift a TriFunction into Monadic form. A good use case it to take an existing method and lift it so it can accept and return monads

 
 TriFunction<AnyMSeq<Double>,AnyMSeq<Entity>,AnyMSeq<String>,AnyMSeq<Integer>> fn = liftM3(this::myMethod);
    
 
 

Now we can execute the Method with Streams, Optional, Futures, Try's etc to transparently inject iteration, null handling, async execution and / or error handling

Specified by:

liftM3Cyclops in interface AnyM<T>

Parameters:

fn - Function to lift

Returns:

Lifted function

liftM4

static <U1,U2,U3,U4,R> org.jooq.lambda.function.Function4<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<U4>,AnyMSeq<R>> liftM4(org.jooq.lambda.function.Function4<? super U1,? super U2,? super U3,? super U4,? extends R> fn)

Lift a jOOλ Function4 into Monadic form.

Specified by:

liftM4 in interface AnyM<T>

Parameters:

fn - Quad funciton to lift

Returns:

Lifted Quad function

liftM4Cyclops

static <U1,U2,U3,U4,R> QuadFunction<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<U4>,AnyMSeq<R>> liftM4Cyclops(QuadFunction<? super U1,? super U2,? super U3,? super U4,? extends R> fn)

Lift a QuadFunction into Monadic form.

Specified by:

liftM4Cyclops in interface AnyM<T>

Parameters:

fn - Quad funciton to lift

Returns:

Lifted Quad function

liftM5

static <U1,U2,U3,U4,U5,R> org.jooq.lambda.function.Function5<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<U4>,AnyMSeq<U5>,AnyMSeq<R>> liftM5(org.jooq.lambda.function.Function5<? super U1,? super U2,? super U3,? super U4,? super U5,? extends R> fn)

Lift a jOOλ Function5 (5 parameters) into Monadic form

Specified by:

liftM5 in interface AnyM<T>

Parameters:

fn - Function to lift

Returns:

Lifted Function

liftM5Cyclops

static <U1,U2,U3,U4,U5,R> QuintFunction<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<U4>,AnyMSeq<U5>,AnyMSeq<R>> liftM5Cyclops(QuintFunction<? super U1,? super U2,? super U3,? super U4,? super U5,? extends R> fn)

Lift a QuintFunction (5 parameters) into Monadic form

Specified by:

liftM5Cyclops in interface AnyM<T>

Parameters:

fn - Function to lift

Returns:

Lifted Function

liftM2

static <U1,U2,R> java.util.function.Function<AnyMSeq<U1>,java.util.function.Function<AnyMSeq<U2>,AnyMSeq<R>>> liftM2(java.util.function.Function<U1,java.util.function.Function<U2,R>> fn)

Lift a Curried Function into Monadic form

Specified by:

liftM2 in interface AnyM<T>

Parameters:

fn - Function to lift

Returns:

Lifted function

liftM3

static <U1,U2,U3,R> java.util.function.Function<AnyMSeq<U1>,java.util.function.Function<AnyMSeq<U2>,java.util.function.Function<AnyMSeq<U3>,AnyMSeq<R>>>> liftM3(java.util.function.Function<? super U1,java.util.function.Function<? super U2,java.util.function.Function<? super U3,? extends R>>> fn)

Lift a Curried Function into Monadic form

Specified by:

liftM3 in interface AnyM<T>

Parameters:

fn - Function to lift

Returns:

Lifted function

liftM4

static <U1,U2,U3,U4,R> java.util.function.Function<AnyMSeq<U1>,java.util.function.Function<AnyMSeq<U2>,java.util.function.Function<AnyMSeq<U3>,java.util.function.Function<AnyMSeq<U4>,AnyMSeq<R>>>>> liftM4(java.util.function.Function<? super U1,java.util.function.Function<? super U2,java.util.function.Function<? super U3,java.util.function.Function<? super U4,? extends R>>>> fn)

Lift a Curried Function into Monadic form

Specified by:

liftM4 in interface AnyM<T>

Parameters:

fn - Function to lift

Returns:

Lifted function

liftM5

static <U1,U2,U3,U4,U5,R> java.util.function.Function<AnyMSeq<U1>,java.util.function.Function<AnyMSeq<U2>,java.util.function.Function<AnyMSeq<U3>,java.util.function.Function<AnyMSeq<U4>,java.util.function.Function<AnyMSeq<U5>,AnyMSeq<R>>>>>> liftM5(java.util.function.Function<? super U1,java.util.function.Function<? super U2,java.util.function.Function<? super U3,java.util.function.Function<? super U4,java.util.function.Function<? super U5,? extends R>>>>> fn)

Lift a Curried Function (5 levels a->b->c->d->e->fn.apply(a,b,c,d,e) ) into Monadic form

Specified by:

liftM5 in interface AnyM<T>

Parameters:

fn - Function to lift

Returns:

Lifted function