AnyMSeq (simple-react 1.0.0-RC4 API)

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>, IterableFoldable<T>, IterableFunctor<T>, org.reactivestreams.Publisher<T>, ReactiveStreamsTerminalOperations<T>, Sequential<T>, ToStream<T>, TransformerTraversable<T>, Traversable<T>, Unit<T>, Unwrapable, ZippingApplicativable<T>

All Known Implementing Classes:

AnyMSeqImpl
```
public interface AnyMSeq<T>
extends AnyM<T>, IterableFoldable<T>, ConvertableSequence<T>, ExtendedTraversable<T>, Sequential<T>, CyclopsCollectable<T>, FilterableFunctor<T>, ZippingApplicativable<T>, ReactiveStreamsTerminalOperations<T>, org.reactivestreams.Publisher<T>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface com.aol.cyclops.control.AnyM
  AnyM.AnyMFactory

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
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<? 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
`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()`
`default boolean`	`eqv(AnyMSeq<T> t)` Equivalence test
`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)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<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.
`<R> AnyMSeq<R>`	`flatMapFirst(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)` Perform a flatMap operation that will only work as normal for AnyMSeq types, but for AnyMValue (which can only hold a single value) will take the first value from the Iterable returned.
`<R> AnyMSeq<R>`	`flatMapFirstPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)` Perform a flatMap operation that will only work as normal for AnyMSeq types, but for AnyMValue (which can only hold a single value) will take the first value from the Publisher returned.
`<T1> AnyMSeq<T1>`	`flatten()` join / flatten one level of a nested hierarchy
`default IterableFoldable<T>`	`foldable()`
`<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 Travesable of Lists where each List is populated while the supplied bipredicate holds.
`default AnyMSeq<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<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 Traversable 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
`default AnyMSeq<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`default AnyMSeq<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`default AnyMSeq<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<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
`<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<? extends U> type)` Keep only those elements in a stream that are of a given type.
`default AnyMSeq<T>`	`onEmpty(T value)`
`default AnyMSeq<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)`
`default <X extends java.lang.Throwable> AnyMSeq<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)`
`default <R> AnyMSeq<R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<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<? super U,? super T,? extends 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,? super U,? extends 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 <T> AnyMSeq<java.util.stream.Stream<T>>`	`sequence(java.util.stream.Stream<AnyMSeq<T>> source, java.util.function.Supplier<AnyMSeq<java.util.stream.Stream<T>>> unitEmpty)` Convert a Stream of Monads to a Monad with a Stream
`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
`default Traversable<T>`	`traversable()`
`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
`static <T,R> AnyMSeq<java.util.stream.Stream<R>>`	`traverse(java.util.stream.Stream<AnyMSeq<T>> source, java.util.function.Supplier<AnyMSeq<java.util.stream.Stream<T>>> unitEmpty, java.util.function.Function<? super T,? extends R> fn)` Convert a Stream of Monads to a Monad with a Stream 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
`<U> AnyMSeq<U>`	`unitIterator(java.util.Iterator<U> U)`
`<R> R`	`unwrap()` Unwrap a wrapped value
`default <U> AnyMSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)`
`default <U,R> AnyMSeq<R>`	`zip(java.lang.Iterable<? extends 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<? extends U> other)`
`default <U,R> AnyMSeq<R>`	`zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <U> AnyMSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.util.stream.Stream<? extends U> other)` Zip 2 streams into one
`default <U,R> AnyMSeq<R>`	`zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`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<? extends T2> second, java.util.stream.Stream<? extends T3> third, java.util.stream.Stream<? extends T4> fourth)` zip 4 Streams into 1
`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
eqv, fromArray, fromCompletableFuture, fromCompletableFutureTSeq, fromCompletableFutureTValue, fromDoubleStream, fromEval, fromEvalTSeq, fromEvalTValue, fromFeatureToggle, fromFutureW, fromFutureWTSeq, fromFutureWTValue, fromIntStream, fromIor, fromIterable, fromIterableValue, fromList, fromListT, fromLongStream, fromMaybe, fromMaybeTSeq, fromMaybeTValue, fromOptional, fromOptionalDouble, fromOptionalInt, fromOptionalLong, fromOptionalTSeq, fromOptionalTValue, fromPublisher, fromRange, fromRangeLong, fromSet, fromSetT, fromStream, fromStreamable, fromStreamableT, fromStreamT, fromTry, fromTryTSeq, fromTryTValue, fromXor, fromXorTSeq, fromXorTValue, 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
futureStream, getStreamable, isEmpty, iterator, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream

Methods inherited from interface com.aol.cyclops.types.IterableFoldable
headAndTail, visit

Methods inherited from interface com.aol.cyclops.types.TransformerTraversable
groupedStatefullyWhileT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT

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, bitAnd, bitAnd, bitAndInt, bitAndLong, bitOr, bitOr, bitOrInt, bitOrLong, 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, sum, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, 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.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

Methods inherited from interface com.aol.cyclops.types.Foldable
endsWith, endsWithIterable, findAny, findFirst, firstValue, 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, validate, xMatch

Methods inherited from interface com.aol.cyclops.types.Traversable
futureOperations, lazyOperations

Methods inherited from interface com.aol.cyclops.types.stream.ConvertableSequence
seq, toCompletableFuture, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toOptional, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface com.aol.cyclops.types.stream.reactive.ReactiveStreamsTerminalOperations
forEachEvent, forEachWithError, forEachX, forEachXEvents, forEachXWithError

Method Detail

eqv
```
default boolean eqv(AnyMSeq<T> t)
```
Equivalence test

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>

flatMapFirst
```
<R> AnyMSeq<R> flatMapFirst(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)
```
Perform a flatMap operation that will only work as normal for AnyMSeq types, but for AnyMValue (which can only hold a single value) will take the first value from the Iterable returned.

Specified by:

flatMapFirst in interface AnyM<T>

Parameters:

fn - FlatMaping function

Returns:

AnyM with flattening transformation

flatMapFirstPublisher
```
<R> AnyMSeq<R> flatMapFirstPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
Perform a flatMap operation that will only work as normal for AnyMSeq types, but for AnyMValue (which can only hold a single value) will take the first value from the Publisher returned.

Specified by:

flatMapFirstPublisher in interface AnyM<T>

Parameters:

fn - FlatMaping function

Returns:

AnyM with flattening transformation

traversable
```
default Traversable<T> traversable()
```
Specified by:

traversable in interface Traversable<T>

foldable
```
default IterableFoldable<T> foldable()
```
Specified by:

foldable in interface Foldable<T>

Specified by:

foldable in interface IterableFoldable<T>

limit
```
default AnyMSeq<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<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<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<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<T> onEmpty(T value)
```
Specified by:

onEmpty in interface Traversable<T>

onEmptyGet

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

Specified by:: onEmptyGet in interface Traversable<T>

onEmptyThrow

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

Specified by:: onEmptyThrow in interface Traversable<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  AnyMSeq cast(java.lang.Class<? extends 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.CheckValue1<T,R>,Matchable.CheckValue1<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<? extends U> other,
                             java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Specified by:: zip in interface Traversable<T>

zip

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

Specified by:: zip in interface Traversable<T>

zip

default <U,R> AnyMSeq<R> zip(org.jooq.lambda.Seq<? extends U> other,
                             java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Specified by:: zip in interface Traversable<T>

zip

default <U> AnyMSeq<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.util.stream.Stream<? extends 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>

zip

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

Specified by:: zip in interface Traversable<T>

zip

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

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<? extends T2> second,
                                                                          java.util.stream.Stream<? extends T3> third,
                                                                          java.util.stream.Stream<? extends 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 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, 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 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)
 .groupedStatefullyWhile((s,i)->s.contains(4) ? true : false)
 .toList().size(),equalTo(5));
 
 
```
Specified by:

groupedStatefullyWhile in interface Traversable<T>

Parameters:

predicate - Window while true

Returns:

Traversable 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 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, 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<? 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<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,? 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<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<? extends 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)
```
Description copied from interface: Filterable
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 Filterable<T>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filterable with elements removed where the predicate does not hold

unitIterator
```
 AnyMSeq unitIterator(java.util.Iterator U)
```
Specified by:

unitIterator in interface IterableFunctor<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 ExtendedTraversable<T>

Specified by:

stream in interface Foldable<T>

Specified by:

stream in interface IterableFunctor<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:

SequenceM from this Streamable

unwrap
```
<R> R unwrap()
```
Description copied from interface: Unwrapable

Unwrap a wrapped value

Specified by:

unwrap in interface AnyM<T>

Specified by:

unwrap in interface Unwrapable

Returns:

wrapped value

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>

Parameters:

fn - Transformation function

Returns:

Transformed Functor

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

traverse

static <T,R> AnyMSeq<java.util.stream.Stream<R>> traverse(java.util.stream.Stream<AnyMSeq<T>> source,
                                                          java.util.function.Supplier<AnyMSeq<java.util.stream.Stream<T>>> unitEmpty,
                                                          java.util.function.Function<? super T,? extends R> fn)

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

sequence

static <T> AnyMSeq<java.util.stream.Stream<T>> sequence(java.util.stream.Stream<AnyMSeq<T>> source,
                                                        java.util.function.Supplier<AnyMSeq<java.util.stream.Stream<T>>> unitEmpty)

Convert a Stream of Monads to a Monad with a Stream

liftM
```
static <U,R> java.util.function.Function<AnyMSeq,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

Interface AnyMSeq<T>

Nested Class Summary

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

Method Summary

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

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

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

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

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

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

Methods inherited from interface org.jooq.lambda.Collectable

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

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

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

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

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

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

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.aol.cyclops.types.stream.reactive.ReactiveStreamsTerminalOperations

Method Detail

eqv

collect

flatMapFirst

flatMapFirstPublisher

traversable

foldable

limit

limitWhile

limitUntil

limitLast

onEmpty

onEmptyGet

onEmptyThrow

applicatives

ap1

subscribe

collectable

toFirstValue

toXor

toXorSecondary

cast

trampoline

patternMatch

cycle

cycle

cycleWhile

cycleUntil

zip

zip

zip

zip

zip

zip

zip3

zip4

zipWithIndex

sliding

sliding

grouped

groupedUntil

groupedStatefullyWhile

combine

groupedWhile

groupedWhile

groupedUntil

grouped

grouped

grouped

takeWhile

dropWhile

takeUntil

dropUntil

dropRight

takeRight

reverse

shuffle

shuffle

distinct

scanLeft

scanLeft