AnyM2 (cyclops-reactor 9.0.0-FINAL API)

Type Parameters:

T - type data wrapped by the underlying monad

All Superinterfaces:

AnyM<W,T>, ConvertableToReactiveSeq<T>, EmptyUnit<T>, Filters<T>, Folds<T>, java.lang.Iterable<T>, org.reactivestreams.Publisher<T>, To<AnyM<W,T>>, ToStream<T>, Transformable<T>, Unit<T>, Unwrapable, Zippable<T>

All Known Subinterfaces:

AnyMValue2<W,T2,T>

All Known Implementing Classes:

AnyMValue2Impl
```
public interface AnyM2<W extends WitnessType<W>,T2,T>
extends AnyM<W,T>, Unwrapable, EmptyUnit<T>, Unit<T>, Folds<T>, Transformable<T>, ToStream<T>, Zippable<T>, org.reactivestreams.Publisher<T>
```
Wrapper for Any Monad type There are two subsclass of AnyM - @see AnyMValue and @see AnyMSeq. AnyMValue is used to represent Monads that wrap a singleUnsafe value such as Optional, CompletableFuture, Maybe, Eval, Xor, Try, Ior, FeatureToggle AnyMSeq is used to represent Monads that wrap an aggregation of values such as Stream, FutureStream, List, Set, Streamable Use AnyM to create your monad wrapper. AnyM.fromXXXX methods can create the appropriate AnyM type for a range of known monad types.
```
  
    AnyMValue<optional,String> monad1 = AnyM.fromOptional(Optional.of("hello"));
    
    AnyMSeq<stream,String> monad2 = AnyM.fromStream(Stream.of("hello","world"));
  
 
 
```
Wrapped monads can be unwrapped via the unwrap method, or converted to the desired type via toXXXX methods

Nested Class Summary
- Nested classes/interfaces inherited from interface cyclops.monads.AnyM
  AnyM.AnyMFactory

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`FunctionalAdapter<W>`	`adapter()`
`default AnyM2<W,T2,java.util.List<T>>`	`aggregate(AnyM2<W,T2,T> next)` Aggregate the contents of this Monad and the supplied Monad
`static <W extends WitnessType<W>,T2,T,R> java.util.function.Function<AnyM2<W,T2,T>,AnyM2<W,T2,R>>`	`ap(AnyM2<W,T2,java.util.function.Function<T,R>> fn)` Applicative 'ap' method to use fluently
`static <W extends WitnessType<W>,T2,T,R,T3> java.util.function.BiFunction<AnyM2<W,T3,T>,AnyM2<W,T3,T2>,AnyM2<W,T3,R>>`	`ap2(AnyM2<W,T3,java.util.function.Function<T,java.util.function.Function<T2,R>>> fn)` Applicative ap2 method to use fluently to applyHKT to a curried function
`default <R> AnyM2<W,T2,R>`	`coflatMapA(java.util.function.Function<? super AnyM<W,T>,R> mapper)`
`default <R,A> R`	`collect(java.util.stream.Collector<? super T,A,R> collector)` Collect the contents of the monad wrapped by this AnyM into supplied collector A mutable reduction operation equivalent to Stream#collect
`default <T> AnyM2<W,T2,T>`	`empty()` Construct an AnyM wrapping a new zero instance of the wrapped type e.g.
`default <T> Unit<T>`	`emptyUnit()`
`default boolean`	`eqv(AnyM2<?,T2,T> t)` Tests for equivalency between two AnyM types
`default AnyM2<W,T2,T>`	`filter(java.util.function.Predicate<? super T> fn)` Perform a filter operation on the wrapped monad instance e.g.
`default <R> AnyM2<W,T2,R>`	`flatMapA(java.util.function.Function<? super T,? extends AnyM<W,? extends R>> fn)`
`<R> AnyM2<W,T2,R>`	`flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)`
`<R> AnyM2<W,T2,R>`	`flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`<R> AnyM2<W,T2,R>`	`flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)`
`static <W extends WitnessType<W>,T1,T2> AnyM2<W,T2,T1>`	`flatten(AnyM2<W,T2,? extends AnyM2<W,T2,T1>> nested)` join / flatten one level of a nest hierarchy
`static <W extends WitnessType<W>,T1,T2> AnyM2<W,T2,T1>`	`flattenI(AnyM2<W,T2,? extends java.lang.Iterable<T1>> nested)`
`default <T> AnyM2<W,T2,T>`	`fromIterable(java.lang.Iterable<T> t)`
`default java.util.Iterator<T>`	`iterator()`
`static <W extends WitnessType<W>,U,R> AnyMFn1<W,U,R>`	`liftF(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 <W extends WitnessType<W>,U1,U2,R> AnyMFn2<W,U1,U2,R>`	`liftF2(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 <W extends WitnessType<W>,U1,U2,R,T2> java.util.function.Function<AnyM2<W,T2,U1>,java.util.function.Function<AnyM2<W,T2,U2>,AnyM2<W,T2,R>>>`	`liftF2(java.util.function.Function<U1,java.util.function.Function<U2,R>> fn)` Lift a Curried Function into Monadic form
`static <W extends WitnessType<W>,U1,U2,U3,R,T2> java.util.function.Function<AnyM2<W,T2,U1>,java.util.function.Function<AnyM2<W,T2,U2>,java.util.function.Function<AnyM2<W,T2,U3>,AnyM2<W,T2,R>>>>`	`liftF3(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 <W extends WitnessType<W>,U1,U2,U3,T2,R> Fn3<AnyM2<W,T2,U1>,AnyM2<W,T2,U2>,AnyM2<W,T2,U3>,AnyM2<W,T2,R>>`	`liftF3(org.jooq.lambda.function.Function3<? super U1,? super U2,? super U3,? extends R> fn)` Lift a TriFunction into Monadic form.
`static <W extends WitnessType<W>,U1,U2,U3,U4,T2,R> java.util.function.Function<AnyM2<W,T2,U1>,java.util.function.Function<AnyM2<W,T2,U2>,java.util.function.Function<AnyM2<W,T2,U3>,java.util.function.Function<AnyM2<W,T2,U4>,AnyM2<W,T2,R>>>>>`	`liftF4(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 <W extends WitnessType<W>,U1,U2,U3,U4,T2,R> Fn4<AnyM2<W,T2,U1>,AnyM2<W,T2,U2>,AnyM2<W,T2,U3>,AnyM2<W,T2,U4>,AnyM2<W,T2,R>>`	`liftF4(org.jooq.lambda.function.Function4<? super U1,? super U2,? super U3,? super U4,? extends R> fn)` Lift a QuadFunction into Monadic form.
`static <W extends WitnessType<W>,U1,U2,U3,U4,U5,R,T2> java.util.function.Function<AnyM2<W,T2,U1>,java.util.function.Function<AnyM2<W,T2,U2>,java.util.function.Function<AnyM2<W,T2,U3>,java.util.function.Function<AnyM2<W,T2,U4>,java.util.function.Function<AnyM2<W,T2,U5>,AnyM2<W,T2,R>>>>>>`	`liftF5(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.applyHKT(a,b,c,d,e) )` into Monadic form
`static <W extends WitnessType<W>,U1,U2,U3,U4,U5,R,T2> Fn5<AnyM2<W,T2,U1>,AnyM2<W,T2,U2>,AnyM2<W,T2,U3>,AnyM2<W,T2,U4>,AnyM2<W,T2,U5>,AnyM2<W,T2,R>>`	`liftF5(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
`default FutureT<W,T>`	`liftMFuture()`
`default FutureT<W,T>`	`liftMFuture(java.util.function.Function<? super T,? extends Future<T>> lift)`
`default ListT<W,T>`	`liftMList(java.util.function.Function<? super T,? extends IndexedSequenceX<T>> lift)`
`default ListT<W,T>`	`liftMListX()`
`default <R> AnyM2<W,T2,R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`Xor<AnyMValue<W,T>,AnyMSeq<W,T>>`	`matchable()` Allows structural matching on the value / seq nature of this AnyM.
`static <W extends WitnessType<W>,T2,T> AnyM2<W,T2,T>`	`narrow(AnyM2<W,? extends T,? extends T2> anyM)`
`default AnyM2<W,T2,AnyM<W,T>>`	`nestA()`
`default AnyM2<W,T2,T>`	`peek(java.util.function.Consumer<? super T> c)` Perform a peek operation on the wrapped monad e.g.
`default ReactiveSeq<T>`	`reactiveSeq()`
`default <R> AnyM2<W,T2,R>`	`retry(java.util.function.Function<? super T,? extends R> fn)` Retry a transformation if it fails.
`default <R> AnyM2<W,T2,R>`	`retry(java.util.function.Function<? super T,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit)` Retry a transformation if it fails.
`static <W extends WitnessType<W>,T1,T2> AnyM2<W,T2,ListX<T1>>`	`sequence(java.util.Collection<? extends AnyM2<W,T2,T1>> seq, W w)` Convert a Collection of Monads to a Monad with a List
`static <W extends WitnessType<W>,T2,T> AnyM2<W,T2,java.util.stream.Stream<T>>`	`sequence(java.util.stream.Stream<? extends AnyM2<W,T2,T>> stream, W witness)`
`default ReactiveSeq<T>`	`stream()`
`default <R> R`	`to2(java.util.function.Function<? super AnyM2<W,T2,T>,? extends R> reduce)` Fluent api for type conversion
`java.lang.String`	`toString()`
`static <W extends WitnessType<W>,T,T2,R> AnyM2<W,T2,ListX<R>>`	`traverse(java.util.Collection<? extends AnyM2<W,T2,T>> seq, java.util.function.Function<? super T,? extends R> fn, W w)` Convert a Collection of Monads to a Monad with a List applying the supplied function in the process
`static <W extends WitnessType<W>,T2,T,R> AnyM2<W,T2,java.util.stream.Stream<R>>`	`traverse(java.util.function.Function<T,R> fn, java.util.stream.Stream<AnyM2<W,T2,T>> stream, W witness)`
`default <T> AnyM2<W,T2,T>`	`unit(T t)` Construct a new instanceof AnyM using the type of the underlying wrapped monad
`default <U> AnyMSeq<W,U>`	`unitIterator(java.util.Iterator<U> U)`
`default <S,U> AnyM2<W,T2,org.jooq.lambda.tuple.Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)` zip 3 Streams into one
`default <S,U,R> AnyM2<W,T2,R>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Fn3<? super T,? super S,? super U,? extends R> fn3)`
`default <T2,T3,T4> AnyM2<W,T2,org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)` zip 4 Streams into 1
`default <T2,T3,T4,R> AnyM2<W,T2,R>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn)`
`default <U> AnyM2<W,T2,org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipP(org.reactivestreams.Publisher<? extends U> other)`
`default <R> AnyM2<W,T2,R>`	`zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)`
`default <R> AnyM2<W,T2,R>`	`zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)`
`default <R> AnyM2<W,T2,R>`	`zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)`

Methods inherited from interface cyclops.monads.AnyM
aggregate, always, always, ap, ap2, cast, completableFutureOf, eqv, failure, filterNot, flatten, flattenI, fromArray, fromBagX, fromCollectionX, fromCompletableFuture, fromDeque, fromDoubleStream, fromEither, fromEither3, fromEither4, fromEither5, fromEval, fromFuture, fromFutureStream, fromIdentity, fromIntStream, fromIor, fromLinkedListX, fromList, fromLongStream, fromMaybe, fromMonadicValue, fromOptional, fromOptionalDouble, fromOptionalInt, fromOptionalLong, fromOrderedSetX, fromPersistentQueueX, fromPersistentSetX, fromPublisher, fromQueue, fromSet, fromSortedSet, fromStream, fromStream, fromStream, fromStreamable, fromTry, fromVectorX, fromXor, futureOf, generate, identity, just, later, left, liftF3, liftF4, liftF5, listFromCompletableFuture, listFromEither, listFromEither3, listFromEither4, listFromEither5, listFromEval, listFromFuture, listFromIor, listFromMaybe, listFromOptional, listFromStream, listFromStreamable, listFromXor, listOf, maybeNullable, narrow, none, notNull, ofNullable, ofSeq, ofType, ofValue, ofValue, ofValue2, ofValue2, primary, rangeLongOf, rangeOf, right, secondary, sequence, sequence, streamOf, success, success, trampoline, traverse, traverse, zip, zip, zip, zipP, zipS, zipS

Methods inherited from interface com.aol.cyclops2.types.Unwrapable
unwrap, unwrapIfInstance, unwrapNested

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

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleUnsafe, startsWith, startsWithIterable, takeOne, xMatch

Methods inherited from interface com.aol.cyclops2.types.stream.ToStream
futureStream, getStreamable, isEmpty, jdkStream, reveresedJDKStream, reveresedStream

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

Methods inherited from interface org.reactivestreams.Publisher
subscribe

Method Detail

reactiveSeq
```
default ReactiveSeq<T> reactiveSeq()
```
Specified by:

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

Specified by:

reactiveSeq in interface ConvertableToReactiveSeq<T>

Specified by:

reactiveSeq in interface ToStream<T>

Returns:

ReactiveSeq generated from this convertable type

collect

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

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

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

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

Specified by:: collect in interface AnyM<W extends WitnessType<W>,T>
Parameters:: collector - JDK collector to perform mutable reduction
Returns:: Reduced value

iterator
```
default java.util.Iterator<T> iterator()
```
Specified by:

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

Specified by:

iterator in interface java.lang.Iterable<T>

unitIterator
```
default <U> AnyMSeq<W,U> unitIterator(java.util.Iterator<U> U)
```
Specified by:

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

flatMapI

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

Specified by:: flatMapI in interface AnyM<W extends WitnessType<W>,T>

flatMapP

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

Specified by:: flatMapP in interface AnyM<W extends WitnessType<W>,T>

flatMapS

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

Specified by:: flatMapS in interface AnyM<W extends WitnessType<W>,T>

flatMapA

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

Specified by:: flatMapA in interface AnyM<W extends WitnessType<W>,T>

map
```
default <R> AnyM2<W,T2,R> map(java.util.function.Function<? super T,? extends R> fn)
```
Description copied from interface: Transformable
Transform this functor using the supplied transformation function
```
 


    of(1,2,3).map(i->i*2)

    //[2,4,6]

 
 
```
Specified by:

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

Specified by:

map in interface Transformable<T>

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

fromIterable
```
default <T> AnyM2<W,T2,T> fromIterable(java.lang.Iterable<T> t)
```
Specified by:

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

zipWith

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

Specified by:: zipWith in interface AnyM<W extends WitnessType<W>,T>
Specified by:: zipWith in interface Zippable<T>

zipWithS

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

Specified by:: zipWithS in interface AnyM<W extends WitnessType<W>,T>
Specified by:: zipWithS in interface Zippable<T>

zipWithP

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

Specified by:: zipWithP in interface AnyM<W extends WitnessType<W>,T>
Specified by:: zipWithP in interface Zippable<T>

retry

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

Description copied from interface: Transformable

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

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock)
 				.firstValue();

 		//result = 42

Specified by:: retry in interface AnyM<W extends WitnessType<W>,T>
Specified by:: retry in interface Transformable<T>
Parameters:: fn - Function to retry if fails

zipP

default <U> AnyM2<W,T2,org.jooq.lambda.tuple.Tuple2<T,U>> zipP(org.reactivestreams.Publisher<? extends U> other)

Specified by:: zipP in interface AnyM<W extends WitnessType<W>,T>
Specified by:: zipP in interface Zippable<T>

retry

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

Description copied from interface: Transformable

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

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock, 7, 2, TimeUnit.SECONDS)
 				.firstValue();

 		//result = 42

Specified by:: retry in interface AnyM<W extends WitnessType<W>,T>
Specified by:: retry in interface Transformable<T>
Parameters:: fn - Function to retry if fails; retries - Number of retries; delay - Delay in TimeUnits; timeUnit - TimeUnit to use for delay

zip3

default <S,U> AnyM2<W,T2,org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second,
                                                                   java.lang.Iterable<? extends U> third)

Description copied from interface: Zippable

zip 3 Streams into one

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

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

Specified by:: zip3 in interface AnyM<W extends WitnessType<W>,T>
Specified by:: zip3 in interface Zippable<T>

zip3

default <S,U,R> AnyM2<W,T2,R> zip3(java.lang.Iterable<? extends S> second,
                                   java.lang.Iterable<? extends U> third,
                                   Fn3<? super T,? super S,? super U,? extends R> fn3)

Specified by:: zip3 in interface AnyM<W extends WitnessType<W>,T>
Specified by:: zip3 in interface Zippable<T>

zip4

default <T2,T3,T4> AnyM2<W,T2,org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
                                                                             java.lang.Iterable<? extends T3> third,
                                                                             java.lang.Iterable<? extends T4> fourth)

Description copied from interface: Zippable

zip 4 Streams into 1

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

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

Specified by:: zip4 in interface AnyM<W extends WitnessType<W>,T>
Specified by:: zip4 in interface Zippable<T>

zip4

default <T2,T3,T4,R> AnyM2<W,T2,R> zip4(java.lang.Iterable<? extends T2> second,
                                        java.lang.Iterable<? extends T3> third,
                                        java.lang.Iterable<? extends T4> fourth,
                                        Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn)

Specified by:: zip4 in interface AnyM<W extends WitnessType<W>,T>
Specified by:: zip4 in interface Zippable<T>

unit
```
default <T> AnyM2<W,T2,T> unit(T t)
```
Construct a new instanceof AnyM using the type of the underlying wrapped monad
```
 
   AnyM<Integer> ints = AnyM.fromList(Arrays.asList(1,2,3);
   AnyM<String> string = ints.unit("hello");
 
 
```
Specified by:

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

Specified by:

unit in interface Unit<T>

Parameters:

t - to embed inside the monad wrapped by AnyM

Returns:

Newly instantated AnyM

ap

static <W extends WitnessType<W>,T2,T,R> java.util.function.Function<AnyM2<W,T2,T>,AnyM2<W,T2,R>> ap(AnyM2<W,T2,java.util.function.Function<T,R>> fn)

Applicative 'ap' method to use fluently

  
    AnyM<optional,Function<Integer,Integer>> add = AnyM.fromNullable(this::add2);
    add.to(AnyM::ap)
       .applyHKT(AnyM.ofNullable(10));
   
    //AnyM[12] //add 2

Parameters:: fn - Function inside an Applicative
Returns:: Function to applyHKT an Applicative's value to function

ap2

static <W extends WitnessType<W>,T2,T,R,T3> java.util.function.BiFunction<AnyM2<W,T3,T>,AnyM2<W,T3,T2>,AnyM2<W,T3,R>> ap2(AnyM2<W,T3,java.util.function.Function<T,java.util.function.Function<T2,R>>> fn)

Applicative ap2 method to use fluently to applyHKT to a curried function

  
    AnyM<optional,Function<Integer,Function<Integer,Integer>>> add = AnyM.fromNullable(Curry.curry2(this::add));
    add.to(AnyM::ap2)
       .applyHKT(AnyM.ofNullable(10),AnyM.ofNullable(20));
   
    //AnyM[30] //add together

Parameters:: fn - Curried function inside an Applicative
Returns:: Function to applyHKT two Applicative's values to a function

filter

default AnyM2<W,T2,T> filter(java.util.function.Predicate<? super T> fn)

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

 
   AnyM.fromOptional(Optional.of(10)).filter(i->i<10);
 
   //AnyM[Optional.zero()]
   
   AnyM.fromStream(Stream.of(5,10)).filter(i->i<10);
   
   //AnyM[Stream[5]]

Specified by:: filter in interface AnyM<W extends WitnessType<W>,T>
Specified by:: filter in interface Filters<T>
Parameters:: fn - Filtering predicate
Returns:: Filtered AnyM

coflatMapA

default <R> AnyM2<W,T2,R> coflatMapA(java.util.function.Function<? super AnyM<W,T>,R> mapper)

Specified by:: coflatMapA in interface AnyM<W extends WitnessType<W>,T>

nestA
```
default AnyM2<W,T2,AnyM<W,T>> nestA()
```
Specified by:

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

emptyUnit
```
default <T> Unit<T> emptyUnit()
```
Specified by:

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

Specified by:

emptyUnit in interface EmptyUnit<T>

Returns:

A new, zero instance of this EmptyUnit type

eqv

default boolean eqv(AnyM2<?,T2,T> t)

Tests for equivalency between two AnyM types

 
    boolean eqv = AnyM.fromOptional(Optional.of(1)).eqv(AnyM.fromStream(Stream.of(1)));
    //true
     boolean eqv = AnyM.fromOptional(Optional.of(1)).eqv(AnyM.fromStream(Stream.of(1,2)));
    //false

Parameters:: t - AnyM to check for equivalence with this AnyM
Returns:: true if monads are equivalent

matchable
```
Xor<AnyMValue<W,T>,AnyMSeq<W,T>> matchable()
```
Allows structural matching on the value / seq nature of this AnyM. If this AnyM can only store a singleUnsafe value an Xor.secondary with type AnyMValue is returned If this AnyM can store one or many values an Xor.primary with type AnyMSeq is returned
```
 
    AnyM<String> monad;
    
    monad.matchable().visit(v->handleValue(v.get()),s->handleSequence(s.toList()));
 
 
```
Specified by:

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

Returns:

An Xor for pattern matching lazy an AnyMValue or AnyMSeq

stream
```
default ReactiveSeq<T> stream()
```
Specified by:

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

Specified by:

stream in interface Folds<T>

Specified by:

stream in interface ToStream<T>

Returns:

ReactiveSeq from this Streamable

peek
```
default AnyM2<W,T2,T> peek(java.util.function.Consumer<? super T> c)
```
Perform a peek operation on the wrapped monad e.g.
```
  
   AnyM.fromCompletableFuture(CompletableFuture.supplyAsync(()->loadData())
       .peek(System.out::println)
 
 
```
Specified by:

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

Specified by:

peek in interface Transformable<T>

Parameters:

c - Consumer to accept current data

Returns:

AnyM after peek operation

flatten

static <W extends WitnessType<W>,T1,T2> AnyM2<W,T2,T1> flatten(AnyM2<W,T2,? extends AnyM2<W,T2,T1>> nested)

join / flatten one level of a nest hierarchy

Returns:: Flattened / joined one level

flattenI

static <W extends WitnessType<W>,T1,T2> AnyM2<W,T2,T1> flattenI(AnyM2<W,T2,? extends java.lang.Iterable<T1>> nested)

aggregate

default AnyM2<W,T2,java.util.List<T>> aggregate(AnyM2<W,T2,T> next)

Aggregate the contents of this Monad and the supplied Monad

 
 
 AnyM.fromStream(Stream.of(1,2,3,4))
 							.aggregate(fromEither5(Optional.of(5)))
 
 AnyM[Stream[List[1,2,3,4,5]]
 
 List<Integer> result = AnyM.fromStream(Stream.of(1,2,3,4))
 							.aggregate(fromEither5(Optional.of(5)))
 							.toSequence()
                          .flatten()
 							.toList();
    	
    	assertThat(result,equalTo(Arrays.asList(1,2,3,4,5)));

Parameters:: next - Monad to aggregate content with
Returns:: Aggregated Monad

empty
```
default <T> AnyM2<W,T2,T> empty()
```
Construct an AnyM wrapping a new zero instance of the wrapped type e.g.
```
  
 Any<Integer> ints = AnyM.fromStream(Stream.of(1,2,3));
 AnyM<Integer> zero=ints.zero();
 
 
```
Specified by:

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

Returns:

Empty AnyM

toString
```
java.lang.String toString()
```
Specified by:

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

Overrides:

toString in class java.lang.Object

Returns:

String representation of this AnyM

sequence

static <W extends WitnessType<W>,T1,T2> AnyM2<W,T2,ListX<T1>> sequence(java.util.Collection<? extends AnyM2<W,T2,T1>> seq,
                                                                       W w)

Convert a Collection of Monads to a Monad with a List

 
        List<CompletableFuture<Integer>> futures = createFutures();
        AnyM<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

traverse

static <W extends WitnessType<W>,T,T2,R> AnyM2<W,T2,ListX<R>> traverse(java.util.Collection<? extends AnyM2<W,T2,T>> seq,
                                                                       java.util.function.Function<? super T,? extends R> fn,
                                                                       W w)

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

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

Parameters:: seq - Collection of Monads; fn - Function to applyHKT
Returns:: Monad with a list

sequence

static <W extends WitnessType<W>,T2,T> AnyM2<W,T2,java.util.stream.Stream<T>> sequence(java.util.stream.Stream<? extends AnyM2<W,T2,T>> stream,
                                                                                       W witness)

traverse

static <W extends WitnessType<W>,T2,T,R> AnyM2<W,T2,java.util.stream.Stream<R>> traverse(java.util.function.Function<T,R> fn,
                                                                                         java.util.stream.Stream<AnyM2<W,T2,T>> stream,
                                                                                         W witness)

adapter
```
FunctionalAdapter<W> adapter()
```
Specified by:

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

narrow

static <W extends WitnessType<W>,T2,T> AnyM2<W,T2,T> narrow(AnyM2<W,? extends T,? extends T2> anyM)

liftF
```
static <W extends WitnessType<W>,U,R> AnyMFn1<W,U,R> liftF(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:

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

Parameters:

fn -

Returns:

liftF2
```
static <W extends WitnessType<W>,U1,U2,R> AnyMFn2<W,U1,U2,R> liftF2(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<AnyM<Integer>,AnyM<Integer>,AnyM<Integer>> add = Monads.liftF2(this::add);
   
  Optional<Integer> result = add.applyHKT(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 / zero value cases.
Specified by:

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

Parameters:

fn - BiFunction to lift

Returns:

Lifted BiFunction

liftF3
```
static <W extends WitnessType<W>,U1,U2,U3,T2,R> Fn3<AnyM2<W,T2,U1>,AnyM2<W,T2,U2>,AnyM2<W,T2,U3>,AnyM2<W,T2,R>> liftF3(org.jooq.lambda.function.Function3<? 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<AnyM<Double>,AnyM<Entity>,AnyM<W,String>,AnyM<Integer>> fn = liftF3(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
Parameters:

fn - Function to lift

Returns:

Lifted function

liftF4

static <W extends WitnessType<W>,U1,U2,U3,U4,T2,R> Fn4<AnyM2<W,T2,U1>,AnyM2<W,T2,U2>,AnyM2<W,T2,U3>,AnyM2<W,T2,U4>,AnyM2<W,T2,R>> liftF4(org.jooq.lambda.function.Function4<? super U1,? super U2,? super U3,? super U4,? extends R> fn)

Lift a QuadFunction into Monadic form.

Parameters:: fn - Quad funciton to lift
Returns:: Lifted Quad function

liftF5

static <W extends WitnessType<W>,U1,U2,U3,U4,U5,R,T2> Fn5<AnyM2<W,T2,U1>,AnyM2<W,T2,U2>,AnyM2<W,T2,U3>,AnyM2<W,T2,U4>,AnyM2<W,T2,U5>,AnyM2<W,T2,R>> liftF5(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

Parameters:: fn - Function to lift
Returns:: Lifted Function

liftF2

static <W extends WitnessType<W>,U1,U2,R,T2> java.util.function.Function<AnyM2<W,T2,U1>,java.util.function.Function<AnyM2<W,T2,U2>,AnyM2<W,T2,R>>> liftF2(java.util.function.Function<U1,java.util.function.Function<U2,R>> fn)

Lift a Curried Function into Monadic form

Specified by:: liftF2 in interface AnyM<W extends WitnessType<W>,T>
Parameters:: fn - Function to lift
Returns:: Lifted function

liftF3

static <W extends WitnessType<W>,U1,U2,U3,R,T2> java.util.function.Function<AnyM2<W,T2,U1>,java.util.function.Function<AnyM2<W,T2,U2>,java.util.function.Function<AnyM2<W,T2,U3>,AnyM2<W,T2,R>>>> liftF3(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:: liftF3 in interface AnyM<W extends WitnessType<W>,T>
Parameters:: fn - Function to lift
Returns:: Lifted function

liftF4

static <W extends WitnessType<W>,U1,U2,U3,U4,T2,R> java.util.function.Function<AnyM2<W,T2,U1>,java.util.function.Function<AnyM2<W,T2,U2>,java.util.function.Function<AnyM2<W,T2,U3>,java.util.function.Function<AnyM2<W,T2,U4>,AnyM2<W,T2,R>>>>> liftF4(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:: liftF4 in interface AnyM<W extends WitnessType<W>,T>
Parameters:: fn - Function to lift
Returns:: Lifted function

liftF5

static <W extends WitnessType<W>,U1,U2,U3,U4,U5,R,T2> java.util.function.Function<AnyM2<W,T2,U1>,java.util.function.Function<AnyM2<W,T2,U2>,java.util.function.Function<AnyM2<W,T2,U3>,java.util.function.Function<AnyM2<W,T2,U4>,java.util.function.Function<AnyM2<W,T2,U5>,AnyM2<W,T2,R>>>>>> liftF5(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.applyHKT(a,b,c,d,e) ) into Monadic form

Specified by:: liftF5 in interface AnyM<W extends WitnessType<W>,T>
Parameters:: fn - Function to lift
Returns:: Lifted function

liftMFuture

default FutureT<W,T> liftMFuture(java.util.function.Function<? super T,? extends Future<T>> lift)

Specified by:: liftMFuture in interface AnyM<W extends WitnessType<W>,T>

liftMList

default ListT<W,T> liftMList(java.util.function.Function<? super T,? extends IndexedSequenceX<T>> lift)

Specified by:: liftMList in interface AnyM<W extends WitnessType<W>,T>

liftMFuture
```
default FutureT<W,T> liftMFuture()
```
Specified by:

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

liftMListX
```
default ListT<W,T> liftMListX()
```
Specified by:

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

to2
```
default <R> R to2(java.util.function.Function<? super AnyM2<W,T2,T>,? extends R> reduce)
```
Fluent api for type conversion

Parameters:

reduce - Funtion to convert this type

Returns:

Converted type

Interface AnyM2<W extends WitnessType<W>,T2,T>

Nested Class Summary

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

Method Summary

Methods inherited from interface cyclops.monads.AnyM

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

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

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

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

Methods inherited from interface java.lang.Iterable

Methods inherited from interface org.reactivestreams.Publisher

Method Detail

reactiveSeq

collect

iterator

unitIterator

flatMapI

flatMapP

flatMapS

flatMapA

map

fromIterable

zipWith

zipWithS

zipWithP

retry

zipP

retry

zip3

zip3

zip4

zip4

unit

ap

ap2

filter

coflatMapA

nestA

emptyUnit

eqv

matchable

stream

peek

flatten

flattenI

aggregate

empty

toString

sequence

traverse

sequence

traverse

adapter

narrow

liftF

liftF2

liftF3

liftF4

liftF5

liftF2

liftF3

liftF4

liftF5

liftMFuture

liftMList

liftMFuture

liftMListX

to2