AnyM (cyclops-react 2.0.0-MI1 API)

Type Parameters:

T - type data wrapped by the underlying monad

All Superinterfaces:

ConvertableToReactiveSeq<T>, EmptyUnit<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:

AnyMSeq<W,T>, AnyMValue<W,T>
```
public interface AnyM<W extends WitnessType<W>,T>
extends Unwrapable, To<AnyM<W,T>>, 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 single 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<String> monad1 = AnyM.fromOptional(Optional.of("hello"));
    
    AnyMSeq<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
Modifier and Type Interface and Description

static class AnyM.AnyMFactory

Nested Classes
Modifier and Type	Interface and Description
`static class`	`AnyM.AnyMFactory`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`FunctionalAdapter<W>`	`adapter()`
`default AnyM<W,java.util.List<T>>`	`aggregate(AnyM<W,T> next)` Aggregate the contents of this Monad and the supplied Monad
`static <W extends WitnessType<W>,T,R> java.util.function.Function<AnyM<W,T>,AnyM<W,R>>`	`ap(AnyM<W,java.util.function.Function<T,R>> fn)` Applicative 'ap' method to use fluently
`static <W extends WitnessType<W>,T,T2,R> java.util.function.BiFunction<AnyM<W,T>,AnyM<W,T2>,AnyM<W,R>>`	`ap2(AnyM<W,java.util.function.Function<T,java.util.function.Function<T2,R>>> fn)` Applicative ap2 method to use fluently to apply to a curried function
`default <R> AnyM<W,R>`	`coflatMapA(java.util.function.Function<? super AnyM<W,T>,R> mapper)` 1.
`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> AnyM<W,T>`	`empty()` Construct an AnyM wrapping a new empty instance of the wrapped type e.g.
`default <T> Unit<T>`	`emptyUnit()`
`default boolean`	`eqv(AnyM<?,T> t)` Tests for equivalency between two AnyM types
`default AnyM<W,T>`	`filter(java.util.function.Predicate<? super T> fn)` Perform a filter operation on the wrapped monad instance e.g.
`default <R> AnyM<W,R>`	`flatMapA(java.util.function.Function<? super T,? extends AnyM<W,? extends R>> fn)`
`<R> AnyM<W,R>`	`flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)`
`<R> AnyM<W,R>`	`flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`<R> AnyM<W,R>`	`flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)`
`static <W extends WitnessType<W>,T1> AnyM<W,T1>`	`flatten(AnyM<W,? extends AnyM<W,T1>> nested)` join / flatten one level of a nested hierarchy
`static <W extends WitnessType<W>,T1> AnyM<W,T1>`	`flattenI(AnyM<W,? extends java.lang.Iterable<T1>> nested)`
`static <T> AnyMSeq<Witness.stream,T>`	`fromArray(T... streamData)` Create an AnyM wrapping a Stream of the supplied data
`static <W extends Witness.CollectionXWitness<W>,T> AnyMSeq<W,T>`	`fromCollectionX(CollectionX<T> collection, W witness)`
`static <T> AnyMValue<Witness.completableFuture,T>`	`fromCompletableFuture(java.util.concurrent.CompletableFuture<T> future)` Create an AnyM instance that wraps a CompletableFuture
`static AnyMSeq<Witness.stream,java.lang.Double>`	`fromDoubleStream(java.util.stream.DoubleStream stream)` Create an AnyM instance that wraps an DoubleStream
`static <LT1,T> AnyMValue<Witness.either,T>`	`fromEither(Either<LT1,T> xor)` Create an AnyMValue instance that wraps an Either3
`static <LT1,LT2,T> AnyMValue<Witness.either3,T>`	`fromEither3(Either3<LT1,LT2,T> xor)` Create an AnyMValue instance that wraps an Either3
`static <LT1,LT2,LT3,T> AnyMValue<Witness.either4,T>`	`fromEither4(Either4<LT1,LT2,LT3,T> xor)` Create an AnyMValue instance that wraps an Either4
`static <LT1,LT2,LT3,LT4,T> AnyMValue<Witness.either5,T>`	`fromEither5(Either5<LT1,LT2,LT3,LT4,T> xor)` Create an AnyMValue instance that wraps an Either4
`static <T> AnyMValue<Witness.eval,T>`	`fromEval(Eval<T> eval)` Create an AnyMValue instance that wraps an Eval
`static <T> AnyMValue<Witness.future,T>`	`fromFutureW(Future<T> future)` Create an AnyMValue instance that wraps a Future
`static AnyMSeq<Witness.stream,java.lang.Integer>`	`fromIntStream(java.util.stream.IntStream stream)` Create an AnyM instance that wraps an IntStream
`static <T> AnyMValue<Witness.ior,T>`	`fromIor(Ior<?,T> ior)` Create an AnyMValue instance that wraps an Ior
`default <T> AnyM<W,T>`	`fromIterable(java.lang.Iterable<T> t)`
`static <T> AnyMSeq<Witness.list,T>`	`fromList(java.util.List<T> list)` Create an AnyM from a List This AnyM will convert the List to a Stream under the covers, but will rematerialize the Stream as List if wrap() is called
`static AnyMSeq<Witness.stream,java.lang.Long>`	`fromLongStream(java.util.stream.LongStream stream)` Create an AnyM instance that wraps an LongStream
`static <T> AnyMValue<Witness.maybe,T>`	`fromMaybe(Maybe<T> maybe)` Create an AnyMValue instance that wraps a `Maybe`
`static <W extends Witness.MonadicValueWitness<W>,T> AnyMValue<W,T>`	`fromMonadicValue(MonadicValue<T> eval, W witness)`
`static <T> AnyMValue<Witness.optional,T>`	`fromOptional(java.util.Optional<T> opt)` Create an AnyM instance that wraps an Optional
`static AnyMValue<Witness.optional,java.lang.Double>`	`fromOptionalDouble(java.util.OptionalDouble optional)` Create an AnyM instance that wraps an OptionalDouble
`static AnyMValue<Witness.optional,java.lang.Integer>`	`fromOptionalInt(java.util.OptionalInt optional)` Create an AnyM instance that wraps an OptionalInt
`static AnyMValue<Witness.optional,java.lang.Long>`	`fromOptionalLong(java.util.OptionalLong optional)` Create an AnyM instance that wraps an OptionalLong
`static <T> AnyMSeq<Witness.stream,T>`	`fromPublisher(org.reactivestreams.Publisher<T> publisher)` Construct an AnyM that wraps a reactive-streams Publisher.
`static AnyMSeq<Witness.reactiveSeq,java.lang.Integer>`	`fromRange(int start, int end)` Construct an AnyM instance that wraps a range from skip (inclusive) to take (exclusive) provided The AnyM will contain a SequenceM over the spefied range
`static AnyMSeq<Witness.reactiveSeq,java.lang.Long>`	`fromRangeLong(long start, long end)` Construct an AnyM instance that wraps a range from skip (inclusive) to take (exclusive) provided The AnyM will contain a SequenceM over the spefied range
`static <T> AnyMSeq<Witness.set,T>`	`fromSet(java.util.Set<T> set)` Create an AnyM from a Set This AnyM will convert the Set to a Stream under the covers, but will rematerialize the Stream as Set if wrap() is called
`static <T> AnyMSeq<Witness.reactiveSeq,T>`	`fromStream(ReactiveSeq<T> stream)` Create an AnyM instance that wraps a Stream
`static <T> AnyMSeq<Witness.stream,T>`	`fromStream(java.util.stream.Stream<T> stream)` Create an AnyM instance that wraps a Stream
`static <W extends Witness.StreamWitness<W>,T> AnyMSeq<W,T>`	`fromStream(java.util.stream.Stream<T> stream, W witness)`
`static <T> AnyMSeq<Witness.streamable,T>`	`fromStreamable(ToStream<T> streamable)` Wrap a Streamable inside an AnyM
`static <T> AnyMValue<Witness.tryType,T>`	`fromTry(Try<T,?> trySomething)` Create an AnyMValue instance that wraps a Try
`static <T> AnyMValue<Witness.xor,T>`	`fromXor(Xor<?,T> xor)` Create an AnyMValue instance that wraps an Xor
`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> java.util.function.Function<AnyM<W,U1>,java.util.function.Function<AnyM<W,U2>,AnyM<W,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> java.util.function.Function<AnyM<W,U1>,java.util.function.Function<AnyM<W,U2>,java.util.function.Function<AnyM<W,U3>,AnyM<W,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,R> Fn3<AnyM<W,U1>,AnyM<W,U2>,AnyM<W,U3>,AnyM<W,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,R> java.util.function.Function<AnyM<W,U1>,java.util.function.Function<AnyM<W,U2>,java.util.function.Function<AnyM<W,U3>,java.util.function.Function<AnyM<W,U4>,AnyM<W,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,R> Fn4<AnyM<W,U1>,AnyM<W,U2>,AnyM<W,U3>,AnyM<W,U4>,AnyM<W,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> java.util.function.Function<AnyM<W,U1>,java.util.function.Function<AnyM<W,U2>,java.util.function.Function<AnyM<W,U3>,java.util.function.Function<AnyM<W,U4>,java.util.function.Function<AnyM<W,U5>,AnyM<W,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.apply(a,b,c,d,e) )` into Monadic form
`static <W extends WitnessType<W>,U1,U2,U3,U4,U5,R> Fn5<AnyM<W,U1>,AnyM<W,U2>,AnyM<W,U3>,AnyM<W,U4>,AnyM<W,U5>,AnyM<W,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 FluentSequenceX<T>> lift)`
`default ListT<W,T>`	`liftMListX()`
`static <T> ListX<AnyMValue<Witness.completableFuture,T>>`	`listFromCompletableFuture(java.lang.Iterable<java.util.concurrent.CompletableFuture<T>> anyM)` Take an iterable containing CompletableFutures and convert them into a List of AnyMs e.g.
`static <ST,T> ListX<AnyMValue<Witness.either,T>>`	`listFromEither(java.lang.Iterable<Either<ST,T>> anyM)` Take an iterable containing Either3s and convert them into a List of AnyMs e.g.
`static <ST,LT2,T> ListX<AnyMValue<Witness.either3,T>>`	`listFromEither3(java.lang.Iterable<Either3<ST,LT2,T>> anyM)` Take an iterable containing Either3s and convert them into a List of AnyMs e.g.
`static <ST,LT2,LT3,T> ListX<AnyMValue<Witness.either4,T>>`	`listFromEither4(java.lang.Iterable<Either4<ST,LT2,LT3,T>> anyM)` Take an iterable containing Either3s and convert them into a List of AnyMs e.g.
`static <ST,LT2,LT3,LT4,T> ListX<AnyMValue<Witness.either5,T>>`	`listFromEither5(java.lang.Iterable<Either5<ST,LT2,LT3,LT4,T>> anyM)` Take an iterable containing Either3s and convert them into a List of AnyMs e.g.
`static <T> ListX<AnyMValue<Witness.eval,T>>`	`listFromEval(java.lang.Iterable<Eval<T>> anyM)` Take an iterable containing Evals and convert them into a List of AnyMs e.g.
`static <T> ListX<AnyMValue<Witness.future,T>>`	`listFromFutureW(java.lang.Iterable<Future<T>> anyM)` Take an iterable containing Future and convert them into a List of AnyMs e.g.
`static <ST,T> ListX<AnyMValue<Witness.ior,T>>`	`listFromIor(java.lang.Iterable<Ior<ST,T>> anyM)` Take an iterable containing Iors and convert them into a List of AnyMs e.g.
`static <T> ListX<AnyMValue<Witness.maybe,T>>`	`listFromMaybe(java.lang.Iterable<Maybe<T>> anyM)` Take an iterable containing Maybes and convert them into a List of AnyMs e.g.
`static <T> ListX<AnyMValue<Witness.optional,T>>`	`listFromOptional(java.lang.Iterable<java.util.Optional<T>> anyM)` Take an iterable containing Optionals and convert them into a List of AnyMs e.g.
`static <T> ListX<AnyMSeq<Witness.stream,T>>`	`listFromStream(java.lang.Iterable<java.util.stream.Stream<T>> anyM)` Take an iterable containing Streams and convert them into a List of AnyMs e.g.
`static <T> ListX<AnyMSeq<Witness.streamable,T>>`	`listFromStreamable(java.lang.Iterable<Streamable<T>> anyM)` Take an iterable containing Streamables and convert them into a List of AnyMs e.g.
`static <ST,T> ListX<AnyMValue<Witness.xor,T>>`	`listFromXor(java.lang.Iterable<Xor<ST,T>> anyM)` Take an iterable containing Xors and convert them into a List of AnyMs e.g.
`static <T> AnyMSeq<Witness.list,T>`	`listOf(T... elements)`
`default <R> AnyM<W,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>,T> AnyM<W,T>`	`narrow(AnyM<W,? extends T> anyM)`
`default AnyM<W,AnyM<W,T>>`	`nestA()`
`static <T> AnyMValue<Witness.optional,T>`	`ofNullable(java.lang.Object nullable)` Generate an AnyM that wraps an Optional from the provided nullable object
`static <W extends WitnessType<W>,T> AnyMSeq<W,T>`	`ofSeq(java.lang.Object monad, W witness)` Create an AnyMSeq that wraps the untyped monad
`static <W extends WitnessType<W>,T> AnyMValue<W,T>`	`ofValue(java.lang.Object monad, FunctionalAdapter<?> adapter)`
`static <W extends WitnessType<W>,T> AnyMValue<W,T>`	`ofValue(java.lang.Object monad, W witness)` Create an AnyMValue that wraps the untyped monad
`default AnyM<W,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> AnyM<W,R>`	`retry(java.util.function.Function<? super T,? extends R> fn)` Retry a transformation if it fails.
`default <R> AnyM<W,R>`	`retry(java.util.function.Function<? super T,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit)` Retry a transformation if it fails.
`static <W extends WitnessType<W>,T1> AnyM<W,ListX<T1>>`	`sequence(java.util.Collection<? extends AnyM<W,T1>> seq, W w)` Convert a Collection of Monads to a Monad with a List
`static <W extends WitnessType<W>,T> AnyM<W,java.util.stream.Stream<T>>`	`sequence(java.util.stream.Stream<? extends AnyM<W,T>> stream, W witness)`
`default ReactiveSeq<T>`	`stream()`
`static <T> AnyMSeq<Witness.stream,T>`	`streamOf(T... streamData)` Create an AnyM wrapping a Stream of the supplied data Identical to fromArray, exists as it may appear functionally more obvious to users than fromArray (which fits the convention)
`java.lang.String`	`toString()`
`static <W extends WitnessType<W>,T,R> AnyM<W,ListX<R>>`	`traverse(java.util.Collection<? extends AnyM<W,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>,T,R> AnyM<W,java.util.stream.Stream<R>>`	`traverse(java.util.function.Function<T,R> fn, java.util.stream.Stream<AnyM<W,T>> stream, W witness)`
`default <T> AnyM<W,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> AnyM<W,org.jooq.lambda.tuple.Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)` zip 3 Streams into one
`default <S,U,R> AnyM<W,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> AnyM<W,org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)` zip 4 Streams into 1
`default <T2,T3,T4,R> AnyM<W,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> AnyM<W,org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipP(org.reactivestreams.Publisher<? extends U> other)`
`default <R> AnyM<W,R>`	`zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)`
`default <R> AnyM<W,R>`	`zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)`
`default <R> AnyM<W,R>`	`zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)`

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

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

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

Methods inherited from interface com.aol.cyclops2.types.Zippable
zip, zip, zip, zipP, zipS, zipS

Methods inherited from interface com.aol.cyclops2.types.Transformable
cast, trampoline

Methods inherited from interface org.reactivestreams.Publisher
subscribe

Method Detail

reactiveSeq
```
default ReactiveSeq<T> reactiveSeq()
```
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(Collectors.toList());
      List<Integer> list2 = monad2.collect(Collectors.toList());

Parameters:: collector - JDK collector to perform mutable reduction
Returns:: Reduced value

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

iterator in interface java.lang.Iterable<T>

unitIterator

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

flatMapI

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

flatMapP

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

flatMapS

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

flatMapA

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

map
```
default <R> AnyM<W,R> map(java.util.function.Function<? super T,? extends R> fn)
```
Description copied from interface: Transformable
Transform this functor using the supplied transformation function
```
  
  
  
    of(1,2,3).map(i->i*2)
    
    //[2,4,6]
  
 
 
```
Specified by:

map in interface Transformable<T>

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

fromIterable

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

zipWith

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

Specified by:: zipWith in interface Zippable<T>

zipWithS

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

Specified by:: zipWithS in interface Zippable<T>

zipWithP

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

Specified by:: zipWithP in interface Zippable<T>

retry

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

Description copied from interface: Transformable

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

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


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

 		//result = 42

Specified by:: retry in interface Transformable<T>
Parameters:: fn - Function to retry if fails

zipP

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

Specified by:: zipP in interface Zippable<T>

retry

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

Description copied from interface: Transformable

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

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


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

 		//result = 42

Specified by:: retry in interface 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> AnyM<W,org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second,
                                                               java.lang.Iterable<? extends U> third)

Description copied from interface: Zippable

zip 3 Streams into one

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

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

Specified by:: zip3 in interface Zippable<T>

zip3

default <S,U,R> AnyM<W,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 Zippable<T>

zip4

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

Description copied from interface: Zippable

zip 4 Streams into 1

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

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

Specified by:: zip4 in interface Zippable<T>

zip4

default <T2,T3,T4,R> AnyM<W,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 Zippable<T>

unit
```
default <T> AnyM<W,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 Unit<T>

Parameters:

t - to embed inside the monad wrapped by AnyM

Returns:

Newly instantated AnyM

ap

static <W extends WitnessType<W>,T,R> java.util.function.Function<AnyM<W,T>,AnyM<W,R>> ap(AnyM<W,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)
       .apply(AnyM.ofNullable(10));
   
    //AnyM[12] //add 2

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

ap2

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

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

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

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

filter

default AnyM<W,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.empty()]
   
   AnyM.fromStream(Stream.of(5,10)).filter(i->i<10);
   
   //AnyM[Stream[5]]

Parameters:: fn - Filtering predicate
Returns:: Filtered AnyM

coflatMapA
```
default <R> AnyM<W,R> coflatMapA(java.util.function.Function<? super AnyM<W,T>,R> mapper)
```
1. remove filterable 2. create filterableAnyM subclass with filter operations 3. remove AnyMValue / AnyMseq ? 4. Add combine iterable / zip 5. traverse / sequence methods 6. remove bind method Monad transformers 1. 1 type only AnyM 2. map / filter (if filterable) / flatMap / flatMapT / zip - combine / fold - reduce operations on nested data structures (reduce etc all via map) 3.

nestA
```
default AnyM<W,AnyM<W,T>> nestA()
```

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

emptyUnit in interface EmptyUnit<T>

Returns:

A new, empty instance of this EmptyUnit type

eqv

default boolean eqv(AnyM<?,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 single value an Xor.secondary with type AnyMValue is returned If this AnyM can store one or many values an Xor.primary with type AnyMSeq is returned
```
 
    AnyM<String> monad;
    
    monad.matchable().visit(v->handleValue(v.get()),s->handleSequence(s.toList()));
 
 
```
Returns:

An Xor for pattern matching either an AnyMValue or AnyMSeq

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

stream in interface ToStream<T>

Returns:

ReactiveSeq from this Streamable

peek

default AnyM<W,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 Transformable<T>
Parameters:: c - Consumer to accept current data
Returns:: AnyM after peek operation

flatten

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

join / flatten one level of a nested hierarchy

Returns:: Flattened / joined one level

flattenI

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

aggregate

default AnyM<W,java.util.List<T>> aggregate(AnyM<W,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> AnyM<W,T> empty()

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

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

Returns:: Empty AnyM

toString
```
java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

Returns:

String representation of this AnyM

fromRange
```
static AnyMSeq<Witness.reactiveSeq,java.lang.Integer> fromRange(int start,
                                                                int end)
```
Construct an AnyM instance that wraps a range from skip (inclusive) to take (exclusive) provided The AnyM will contain a SequenceM over the spefied range

Parameters:

start - Inclusive skip of the range

end - Exclusive take of the range

Returns:

AnyM range

fromRangeLong
```
static AnyMSeq<Witness.reactiveSeq,java.lang.Long> fromRangeLong(long start,
                                                                 long end)
```
Construct an AnyM instance that wraps a range from skip (inclusive) to take (exclusive) provided The AnyM will contain a SequenceM over the spefied range

Parameters:

start - Inclusive skip of the range

end - Exclusive take of the range

Returns:

AnyM range

fromStreamable
```
static <T> AnyMSeq<Witness.streamable,T> fromStreamable(ToStream<T> streamable)
```
Wrap a Streamable inside an AnyM

Parameters:

streamable - wrap

Returns:

AnyMSeq generated from a ToStream type

fromList
```
static <T> AnyMSeq<Witness.list,T> fromList(java.util.List<T> list)
```
Create an AnyM from a List This AnyM will convert the List to a Stream under the covers, but will rematerialize the Stream as List if wrap() is called

Parameters:

list - to wrap inside an AnyM

Returns:

AnyM wrapping a list

fromCollectionX

static <W extends Witness.CollectionXWitness<W>,T> AnyMSeq<W,T> fromCollectionX(CollectionX<T> collection,
                                                                                W witness)

fromSet
```
static <T> AnyMSeq<Witness.set,T> fromSet(java.util.Set<T> set)
```
Create an AnyM from a Set This AnyM will convert the Set to a Stream under the covers, but will rematerialize the Stream as Set if wrap() is called

Parameters:

set - to wrap inside an AnyM

Returns:

AnyM wrapping a Set

fromArray
```
static <T> AnyMSeq<Witness.stream,T> fromArray(T... streamData)
```
Create an AnyM wrapping a Stream of the supplied data

Parameters:

streamData - values to populate a Stream

Returns:

AnyMSeq wrapping a Stream that encompasses the supplied Array

streamOf
```
static <T> AnyMSeq<Witness.stream,T> streamOf(T... streamData)
```
Create an AnyM wrapping a Stream of the supplied data Identical to fromArray, exists as it may appear functionally more obvious to users than fromArray (which fits the convention)

Parameters:

streamData - values to populate a Stream

Returns:

AnyMSeq wrapping a Stream that encompasses the supplied Array

listOf

static <T> AnyMSeq<Witness.list,T> listOf(T... elements)

fromPublisher
```
static <T> AnyMSeq<Witness.stream,T> fromPublisher(org.reactivestreams.Publisher<T> publisher)
```
Construct an AnyM that wraps a reactive-streams Publisher. If there is no registered Comprehender for the supplied Publisher, this method will attempt to convert the Publisher to a type that cyclops2-react can understand.
```
   
       AnyMSeq<Integer> flux = AnyM.fromPublisher(Flux.just(10,20,30));
       
       //with cyclops2-reactor
       //AnyM[Flux[Integer]]]
       
       //without cyclops2-reactor
       //AnyM[ReactiveSeq[Integer]]]
  
  
```
It is generally safer to define a Comprehender and use a non-converting call to generate the wrapped AnyM (e.g. Reactor.Flux in cyclops2-reactor for Pivotal Reactor Publishers)
Parameters:

publisher - Publisher to wrap inside an AnyM

Returns:

AnyMSeq that wraps a Publisher

fromStream
```
static <T> AnyMSeq<Witness.reactiveSeq,T> fromStream(ReactiveSeq<T> stream)
```
Create an AnyM instance that wraps a Stream

Parameters:

stream - Stream to wrap

Returns:

AnyM that wraps the provided Stream

fromStream

static <W extends Witness.StreamWitness<W>,T> AnyMSeq<W,T> fromStream(java.util.stream.Stream<T> stream,
                                                                      W witness)

fromStream
```
static <T> AnyMSeq<Witness.stream,T> fromStream(java.util.stream.Stream<T> stream)
```
Create an AnyM instance that wraps a Stream

Parameters:

stream - Stream to wrap

Returns:

AnyM that wraps the provided Stream

fromIntStream
```
static AnyMSeq<Witness.stream,java.lang.Integer> fromIntStream(java.util.stream.IntStream stream)
```
Create an AnyM instance that wraps an IntStream

Parameters:

stream - IntStream to wrap

Returns:

AnyM that wraps the provided IntStream

fromDoubleStream
```
static AnyMSeq<Witness.stream,java.lang.Double> fromDoubleStream(java.util.stream.DoubleStream stream)
```
Create an AnyM instance that wraps an DoubleStream

Parameters:

stream - DoubleStream to wrap

Returns:

AnyM that wraps the provided DoubleStream

fromLongStream
```
static AnyMSeq<Witness.stream,java.lang.Long> fromLongStream(java.util.stream.LongStream stream)
```
Create an AnyM instance that wraps an LongStream

Parameters:

stream - LongStream to wrap

Returns:

AnyM that wraps the provided LongStream

fromOptional
```
static <T> AnyMValue<Witness.optional,T> fromOptional(java.util.Optional<T> opt)
```
Create an AnyM instance that wraps an Optional

Parameters:

opt - Optional to wrap

Returns:

AnyM that wraps the provided Optonal

fromOptionalDouble
```
static AnyMValue<Witness.optional,java.lang.Double> fromOptionalDouble(java.util.OptionalDouble optional)
```
Create an AnyM instance that wraps an OptionalDouble

Parameters:

optional - Optional to wrap

Returns:

AnyM that wraps the provided OptonalDouble

fromOptionalLong
```
static AnyMValue<Witness.optional,java.lang.Long> fromOptionalLong(java.util.OptionalLong optional)
```
Create an AnyM instance that wraps an OptionalLong

Parameters:

optional - OptionalLong to wrap

Returns:

AnyM that wraps the provided OptonalLong

fromOptionalInt
```
static AnyMValue<Witness.optional,java.lang.Integer> fromOptionalInt(java.util.OptionalInt optional)
```
Create an AnyM instance that wraps an OptionalInt

Parameters:

optional - OptionalInt to wrap

Returns:

AnyM that wraps the provided OptonalInt

fromCompletableFuture
```
static <T> AnyMValue<Witness.completableFuture,T> fromCompletableFuture(java.util.concurrent.CompletableFuture<T> future)
```
Create an AnyM instance that wraps a CompletableFuture

Parameters:

future - CompletableFuture to wrap

Returns:

AnyM that wraps the provided CompletableFuture

fromXor
```
static <T> AnyMValue<Witness.xor,T> fromXor(Xor<?,T> xor)
```
Create an AnyMValue instance that wraps an Xor

Parameters:

xor - Xor to wrap inside an AnyM

Returns:

AnyM instance that wraps the provided Xor

fromEither
```
static <LT1,T> AnyMValue<Witness.either,T> fromEither(Either<LT1,T> xor)
```
Create an AnyMValue instance that wraps an Either3

Parameters:

xor - Xor to wrap inside an AnyM

Returns:

AnyM instance that wraps the provided Either

fromEither3
```
static <LT1,LT2,T> AnyMValue<Witness.either3,T> fromEither3(Either3<LT1,LT2,T> xor)
```
Create an AnyMValue instance that wraps an Either3

Parameters:

xor - Xor to wrap inside an AnyM

Returns:

AnyM instance that wraps the provided Either3

fromEither4
```
static <LT1,LT2,LT3,T> AnyMValue<Witness.either4,T> fromEither4(Either4<LT1,LT2,LT3,T> xor)
```
Create an AnyMValue instance that wraps an Either4

Parameters:

xor - Either4 to wrap inside an AnyM

Returns:

AnyM instance that wraps the provided Either4

fromEither5
```
static <LT1,LT2,LT3,LT4,T> AnyMValue<Witness.either5,T> fromEither5(Either5<LT1,LT2,LT3,LT4,T> xor)
```
Create an AnyMValue instance that wraps an Either4

Parameters:

xor - Either4 to wrap inside an AnyM

Returns:

AnyM instance that wraps the provided Either4

fromTry
```
static <T> AnyMValue<Witness.tryType,T> fromTry(Try<T,?> trySomething)
```
Create an AnyMValue instance that wraps a Try

Parameters:

trySomething - to wrap inside an AnyM

Returns:

AnyM instance that wraps the provided Try

fromIor
```
static <T> AnyMValue<Witness.ior,T> fromIor(Ior<?,T> ior)
```
Create an AnyMValue instance that wraps an Ior

Parameters:

ior - to wrap inside an AnyM

Returns:

AnyM instance that wraps the provided Ior

fromEval
```
static <T> AnyMValue<Witness.eval,T> fromEval(Eval<T> eval)
```
Create an AnyMValue instance that wraps an Eval

Parameters:

eval - to wrap inside an AnyM

Returns:

AnyM instance that wraps the provided Eval

fromMonadicValue

static <W extends Witness.MonadicValueWitness<W>,T> AnyMValue<W,T> fromMonadicValue(MonadicValue<T> eval,
                                                                                    W witness)

fromFutureW
```
static <T> AnyMValue<Witness.future,T> fromFutureW(Future<T> future)
```
Create an AnyMValue instance that wraps a Future

Parameters:

future - to wrap inside an AnyM

Returns:

AnyM instance that wraps the provided future

fromMaybe
```
static <T> AnyMValue<Witness.maybe,T> fromMaybe(Maybe<T> maybe)
```
Create an AnyMValue instance that wraps a Maybe

Parameters:

maybe - to wrap inside an AnyM

Returns:

instance that wraps the provided Maybe

ofValue

static <W extends WitnessType<W>,T> AnyMValue<W,T> ofValue(java.lang.Object monad,
                                                           W witness)

Create an AnyMValue that wraps the untyped monad

Parameters:: monad - to wrap inside an AnyM
Returns:: AnyMValue that wraps the supplied monad

ofValue

static <W extends WitnessType<W>,T> AnyMValue<W,T> ofValue(java.lang.Object monad,
                                                           FunctionalAdapter<?> adapter)

ofSeq

static <W extends WitnessType<W>,T> AnyMSeq<W,T> ofSeq(java.lang.Object monad,
                                                       W witness)

Create an AnyMSeq that wraps the untyped monad

Parameters:: monad - to wrap inside an AnyM
Returns:: AnyMSeq that wraps the supplied monad

ofNullable
```
static <T> AnyMValue<Witness.optional,T> ofNullable(java.lang.Object nullable)
```
Generate an AnyM that wraps an Optional from the provided nullable object

Parameters:

nullable - - Nullable object to generate an optional from

Returns:

AnyM wrapping an Optional created with the supplied nullable

listFromStreamable
```
static <T> ListX<AnyMSeq<Witness.streamable,T>> listFromStreamable(java.lang.Iterable<Streamable<T>> anyM)
```
Take an iterable containing Streamables and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = AnyM.listFromStreamable(Arrays.asList(Streamable.of(1,2,3),Streamable.of(10,20,30)); //List[AnyM[Streamable[1,2,3],Streamable[10,20,30]]]

Parameters:

anyM - Iterable containing Streamables

Returns:

List of AnyMs

listFromEither5
```
static <ST,LT2,LT3,LT4,T> ListX<AnyMValue<Witness.either5,T>> listFromEither5(java.lang.Iterable<Either5<ST,LT2,LT3,LT4,T>> anyM)
```
Take an iterable containing Either3s and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = anyMList(Arrays.asList(Either4.right(1),Either4.left(10)); //List[AnyM[Either4:right[1],Either4:left[10]]]

Parameters:

anyM - Iterable containing Eithers

Returns:

List of AnyMs

listFromEither4
```
static <ST,LT2,LT3,T> ListX<AnyMValue<Witness.either4,T>> listFromEither4(java.lang.Iterable<Either4<ST,LT2,LT3,T>> anyM)
```
Take an iterable containing Either3s and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = anyMList(Arrays.asList(Either4.right(1),Either4.left(10)); //List[AnyM[Either4:right[1],Either4:left[10]]]

Parameters:

anyM - Iterable containing Eithers

Returns:

List of AnyMs

listFromEither3
```
static <ST,LT2,T> ListX<AnyMValue<Witness.either3,T>> listFromEither3(java.lang.Iterable<Either3<ST,LT2,T>> anyM)
```
Take an iterable containing Either3s and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = listFromEither3(Arrays.asList(Either3.right(1),Either3.left(10)); //List[AnyM[Either3:right[1],Either3:left[10]]]

Parameters:

anyM - Iterable containing Eithers

Returns:

List of AnyMs

listFromEither
```
static <ST,T> ListX<AnyMValue<Witness.either,T>> listFromEither(java.lang.Iterable<Either<ST,T>> anyM)
```
Take an iterable containing Either3s and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = anyMList(Arrays.asList(Either.right(1),Either.left(10)); //List[AnyM[Either.right[1],Either:left[10]]]

Parameters:

anyM - Iterable containing Eithers

Returns:

List of AnyMs

listFromStream
```
static <T> ListX<AnyMSeq<Witness.stream,T>> listFromStream(java.lang.Iterable<java.util.stream.Stream<T>> anyM)
```
Take an iterable containing Streams and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = AnyM.listFromStream(Arrays.asList(Stream.of(1,2,3),Stream.of(10,20,30)); //List[AnyM[Stream[1,2,3],Stream[10,20,30]]]

Parameters:

anyM - Iterable containing Streams

Returns:

List of AnyMs

listFromOptional
```
static <T> ListX<AnyMValue<Witness.optional,T>> listFromOptional(java.lang.Iterable<java.util.Optional<T>> anyM)
```
Take an iterable containing Optionals and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = AnyM.listFromStreamable(Arrays.asList(Optional.of(1),Optional.of(10)); //List[AnyM[Optional[1],Optional[10]]]

Parameters:

anyM - Iterable containing Optional

Returns:

List of AnyMs

listFromCompletableFuture
```
static <T> ListX<AnyMValue<Witness.completableFuture,T>> listFromCompletableFuture(java.lang.Iterable<java.util.concurrent.CompletableFuture<T>> anyM)
```
Take an iterable containing CompletableFutures and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = AnyM.listFromStreamable(Arrays.asList(CompletableFuture.completedFuture(1),CompletableFuture.supplyAsync(()->10)); //List[AnyM[CompletableFuture[1],CompleteableFuture[10]]]

Parameters:

anyM - Iterable containing CompletableFuture

Returns:

List of AnyMs

listFromXor
```
static <ST,T> ListX<AnyMValue<Witness.xor,T>> listFromXor(java.lang.Iterable<Xor<ST,T>> anyM)
```
Take an iterable containing Xors and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = AnyM.listFromXor(Arrays.asList(Xor.primary(1),Xor.secondary(10)); //List[AnyM[Xor:primary[1],Xor:secondaary[10]]]

Parameters:

anyM - Iterable containing Xors

Returns:

List of AnyMs

listFromIor
```
static <ST,T> ListX<AnyMValue<Witness.ior,T>> listFromIor(java.lang.Iterable<Ior<ST,T>> anyM)
```
Take an iterable containing Iors and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = AnyM.listFromXor(Arrays.asList(Ior.primary(1),Ior.secondary(10)); //List[AnyM[Ior:primary[1],Ior:secondaary[10]]]

Parameters:

anyM - Iterable containing Iors

Returns:

List of AnyMs

listFromMaybe
```
static <T> ListX<AnyMValue<Witness.maybe,T>> listFromMaybe(java.lang.Iterable<Maybe<T>> anyM)
```
Take an iterable containing Maybes and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = AnyM.listFromXor(Arrays.asList(Maybe.just(1),Maybe.just(10)); //List[AnyM[Maybe[1],Maybe[10]]]

Parameters:

anyM - Iterable containing Maybes

Returns:

List of AnyMs

listFromEval
```
static <T> ListX<AnyMValue<Witness.eval,T>> listFromEval(java.lang.Iterable<Eval<T>> anyM)
```
Take an iterable containing Evals and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = AnyM.listFromXor(Arrays.asList(Eval.now(1),Eval.now(10)); //List[AnyM[Eval[1],Eval[10]]]

Parameters:

anyM - Iterable containing Maybes

Returns:

List of AnyMs

listFromFutureW
```
static <T> ListX<AnyMValue<Witness.future,T>> listFromFutureW(java.lang.Iterable<Future<T>> anyM)
```
Take an iterable containing Future and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = AnyM.listFromXor(Arrays.asList(Future.ofResult(1),Future.ofResult(10)); //List[AnyM[Future[1],Future[10]]]

Parameters:

anyM - Iterable containing Maybes

Returns:

List of AnyMs

sequence

static <W extends WitnessType<W>,T1> AnyM<W,ListX<T1>> sequence(java.util.Collection<? extends AnyM<W,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,R> AnyM<W,ListX<R>> traverse(java.util.Collection<? extends AnyM<W,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 apply
Returns:: Monad with a list

sequence

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

traverse

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

adapter
```
FunctionalAdapter<W> adapter()
```

narrow

static <W extends WitnessType<W>,T> AnyM<W,T> narrow(AnyM<W,? extends T> 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.

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.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.
Parameters:

fn - BiFunction to lift

Returns:

Lifted BiFunction

liftF3
```
static <W extends WitnessType<W>,U1,U2,U3,R> Fn3<AnyM<W,U1>,AnyM<W,U2>,AnyM<W,U3>,AnyM<W,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,R> Fn4<AnyM<W,U1>,AnyM<W,U2>,AnyM<W,U3>,AnyM<W,U4>,AnyM<W,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> Fn5<AnyM<W,U1>,AnyM<W,U2>,AnyM<W,U3>,AnyM<W,U4>,AnyM<W,U5>,AnyM<W,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> java.util.function.Function<AnyM<W,U1>,java.util.function.Function<AnyM<W,U2>,AnyM<W,R>>> liftF2(java.util.function.Function<U1,java.util.function.Function<U2,R>> fn)

Lift a Curried Function into Monadic form

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

liftF3

static <W extends WitnessType<W>,U1,U2,U3,R> java.util.function.Function<AnyM<W,U1>,java.util.function.Function<AnyM<W,U2>,java.util.function.Function<AnyM<W,U3>,AnyM<W,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

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

liftF4

static <W extends WitnessType<W>,U1,U2,U3,U4,R> java.util.function.Function<AnyM<W,U1>,java.util.function.Function<AnyM<W,U2>,java.util.function.Function<AnyM<W,U3>,java.util.function.Function<AnyM<W,U4>,AnyM<W,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

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

liftF5

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

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

liftMFuture

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

liftMList

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

liftMFuture
```
default FutureT<W,T> liftMFuture()
```

liftMListX
```
default ListT<W,T> liftMListX()
```

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

Nested Class Summary

Method Summary

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

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

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

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

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

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

fromRange

fromRangeLong

fromStreamable

fromList

fromCollectionX

fromSet

fromArray

streamOf

listOf

fromPublisher

fromStream

fromStream

fromStream

fromIntStream

fromDoubleStream

fromLongStream

fromOptional

fromOptionalDouble

fromOptionalLong

fromOptionalInt

fromCompletableFuture

fromXor

fromEither

fromEither3

fromEither4

fromEither5

fromTry

fromIor

fromEval

fromMonadicValue

fromFutureW

fromMaybe

ofValue

ofValue