AnyM (simple-react 1.0.0-RC4 API)

Type Parameters:

T - type data wrapped by the underlying monad

All Superinterfaces:

ConvertableToReactiveSeq<T>, EmptyUnit<T>, FlatMap<T>, Foldable<T>, Functor<T>, java.lang.Iterable<T>, ToStream<T>, Unit<T>, Unwrapable

All Known Subinterfaces:

AnyMSeq<T>, AnyMValue<T>

All Known Implementing Classes:

AnyMSeqImpl, AnyMValueImpl
```
public interface AnyM<T>
extends Unwrapable, EmptyUnit<T>, Unit<T>, Foldable<T>, Functor<T>, FlatMap<T>, ToStream<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, LazyFutureStream, 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
`AnyM<java.util.List<T>>`	`aggregate(AnyM<T> next)` Aggregate the contents of this Monad and the supplied Monad
`<R> AnyM<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.
`<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
`<T> AnyM<T>`	`empty()` Construct an AnyM wrapping an empty instance of the wrapped type e.g.
`default boolean`	`eqv(AnyM<T> t)`
`AnyM<T>`	`filter(java.util.function.Predicate<? super T> p)` Perform a filter operation on the wrapped monad instance e.g.
`<R> AnyM<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> AnyM<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> AnyM<T1>`	`flatten()` join / flatten one level of a nested hierarchy
`static <T> AnyMSeq<T>`	`fromArray(T... streamData)` Create an AnyM wrapping a Stream of the supplied data
`static <T> AnyMValue<T>`	`fromCompletableFuture(java.util.concurrent.CompletableFuture<T> future)` Create an AnyM instance that wraps a CompletableFuture
`static <T> AnyMSeq<T>`	`fromCompletableFutureTSeq(CompletableFutureTSeq<T> futureT)`
`static <T> AnyMValue<T>`	`fromCompletableFutureTValue(CompletableFutureTValue<T> futureT)`
`static AnyMSeq<java.lang.Double>`	`fromDoubleStream(java.util.stream.DoubleStream stream)` Create an AnyM instance that wraps an DoubleStream
`static <T> AnyMValue<T>`	`fromEval(Eval<T> future)`
`static <T> AnyMSeq<T>`	`fromEvalTSeq(EvalTSeq<T> evalT)`
`static <T> AnyMValue<T>`	`fromEvalTValue(EvalTValue<T> evalT)`
`static <T> AnyMValue<T>`	`fromFeatureToggle(FeatureToggle<T> future)`
`static <T> AnyMValue<T>`	`fromFutureW(FutureW<T> future)`
`static <T> AnyMSeq<T>`	`fromFutureWTSeq(FutureWTSeq<T> futureT)`
`static <T> AnyMValue<T>`	`fromFutureWTValue(FutureWTValue<T> futureT)`
`static AnyMSeq<java.lang.Integer>`	`fromIntStream(java.util.stream.IntStream stream)` Create an AnyM instance that wraps an IntStream
`static <T> AnyMValue<T>`	`fromIor(Ior<?,T> future)`
`static <T> AnyMSeq<T>`	`fromIterable(java.lang.Iterable<T> iterable)` Create an AnyM instance that wraps an Iterable
`static <T> AnyMValue<T>`	`fromIterableValue(java.lang.Iterable<T> iterable)` Use this method to create an AnyMValue from an Iterable.
`static <T> AnyMSeq<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 <T> AnyMSeq<T>`	`fromListT(ListT<T> listT)`
`static AnyMSeq<java.lang.Long>`	`fromLongStream(java.util.stream.LongStream stream)` Create an AnyM instance that wraps an LongStream
`static <T> AnyMValue<T>`	`fromMaybe(Maybe<T> future)`
`static <T> AnyMSeq<T>`	`fromMaybeTSeq(MaybeTSeq<T> maybeT)`
`static <T> AnyMValue<T>`	`fromMaybeTValue(MaybeTValue<T> maybeT)`
`static <T> AnyMValue<T>`	`fromOptional(java.util.Optional<T> optional)` Create an AnyM instance that wraps an Optional
`static AnyMValue<java.lang.Double>`	`fromOptionalDouble(java.util.OptionalDouble optional)` Create an AnyM instance that wraps an OptionalDouble
`static AnyMValue<java.lang.Integer>`	`fromOptionalInt(java.util.OptionalInt optional)` Create an AnyM instance that wraps an OptionalInt
`static AnyMValue<java.lang.Long>`	`fromOptionalLong(java.util.OptionalLong optional)` Create an AnyM instance that wraps an OptionalLong
`static <T> AnyMSeq<T>`	`fromOptionalTSeq(OptionalTSeq<T> optionalT)`
`static <T> AnyMValue<T>`	`fromOptionalTValue(OptionalTValue<T> optionalT)`
`static <T> AnyMSeq<T>`	`fromPublisher(org.reactivestreams.Publisher<T> publisher)`
`static AnyMSeq<java.lang.Integer>`	`fromRange(int start, int end)` Construct an AnyM instance that wraps a range from start (inclusive) to end (exclusive) provided The AnyM will contain a SequenceM over the spefied range
`static AnyMSeq<java.lang.Long>`	`fromRangeLong(long start, long end)` Construct an AnyM instance that wraps a range from start (inclusive) to end (exclusive) provided The AnyM will contain a SequenceM over the spefied range
`static <T> AnyMSeq<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<T>`	`fromSetT(SetT<T> setT)`
`static <T> AnyMSeq<T>`	`fromStream(java.util.stream.Stream<T> stream)` Create an AnyM instance that wraps a Stream
`static <T> AnyMSeq<T>`	`fromStreamable(ToStream<T> streamable)` Wrap a Streamable inside an AnyM
`static <T> AnyMSeq<T>`	`fromStreamableT(StreamableT<T> streamT)`
`static <T> AnyMSeq<T>`	`fromStreamT(StreamT<T> streamT)`
`static <T> AnyMValue<T>`	`fromTry(Try<T,?> future)`
`static <T,X extends java.lang.Throwable> AnyMSeq<T>`	`fromTryTSeq(TryTSeq<T,X> tryT)`
`static <T,X extends java.lang.Throwable> AnyMValue<T>`	`fromTryTValue(TryTValue<T,X> tryT)`
`static <T> AnyMValue<T>`	`fromXor(Xor<?,T> future)`
`static <ST,PT> AnyMSeq<PT>`	`fromXorTSeq(XorTSeq<ST,PT> xorT)`
`static <ST,PT> AnyMValue<PT>`	`fromXorTValue(XorTValue<ST,PT> xorT)`
`static <U,R> java.util.function.Function<AnyM<U>,AnyM<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<AnyM<U1>,AnyM<U2>,AnyM<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<AnyM<U1>,java.util.function.Function<AnyM<U2>,AnyM<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<AnyM<U1>,java.util.function.Function<AnyM<U2>,java.util.function.Function<AnyM<U3>,AnyM<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<AnyM<U1>,AnyM<U2>,AnyM<U3>,AnyM<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<AnyM<U1>,AnyM<U2>,AnyM<U3>,AnyM<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<AnyM<U1>,java.util.function.Function<AnyM<U2>,java.util.function.Function<AnyM<U3>,java.util.function.Function<AnyM<U4>,AnyM<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<AnyM<U1>,AnyM<U2>,AnyM<U3>,AnyM<U4>,AnyM<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<AnyM<U1>,AnyM<U2>,AnyM<U3>,AnyM<U4>,AnyM<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<AnyM<U1>,java.util.function.Function<AnyM<U2>,java.util.function.Function<AnyM<U3>,java.util.function.Function<AnyM<U4>,java.util.function.Function<AnyM<U5>,AnyM<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<AnyM<U1>,AnyM<U2>,AnyM<U3>,AnyM<U4>,AnyM<U5>,AnyM<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<AnyM<U1>,AnyM<U2>,AnyM<U3>,AnyM<U4>,AnyM<U5>,AnyM<R>>`	`liftM5Cyclops(QuintFunction<? super U1,? super U2,? super U3,? super U4,? super U5,? extends R> fn)` Lift a QuintFunction (5 parameters) into Monadic form
`static <T> java.util.List<AnyMValue<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 <T> java.util.List<AnyMValue<T>>`	`listFromEval(java.lang.Iterable<Eval<T>> anyM)`
`static <T> java.util.List<AnyMValue<T>>`	`listFromFutureW(java.lang.Iterable<FutureW<T>> anyM)`
`static <ST,T> java.util.List<AnyMValue<T>>`	`listFromIor(java.lang.Iterable<Ior<ST,T>> anyM)`
`static <T> java.util.List<AnyMSeq<T>>`	`listFromIterable(java.lang.Iterable<java.lang.Iterable<T>> anyM)` Take an iterable containing Streamables and convert them into a List of AnyMs e.g.
`static <T> java.util.List<AnyMSeq<T>>`	`listFromIterator(java.lang.Iterable<java.util.Iterator<T>> anyM)` Take an iterable containing Streamables and convert them into a List of AnyMs e.g.
`static <T> java.util.List<AnyMValue<T>>`	`listFromMaybe(java.lang.Iterable<Maybe<T>> anyM)`
`static <T> java.util.List<AnyMValue<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> java.util.List<AnyMSeq<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> java.util.List<AnyMSeq<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> java.util.List<AnyMValue<T>>`	`listFromXor(java.lang.Iterable<Xor<ST,T>> anyM)`
`<R> AnyM<R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Perform a map operation on the wrapped monad instance e.g.
`Xor<AnyMValue<T>,AnyMSeq<T>>`	`matchable()`
`static <T> AnyMSeq<T>`	`ofConvertableSeq(java.lang.Object monad)`
`static <T> AnyMValue<T>`	`ofConvertableValue(java.lang.Object monad)` Take the supplied object and always attempt to convert it to a Monad type
`static <T> AnyMValue<T>`	`ofNullable(java.lang.Object nullable)` Generate an AnyM that wraps an Optional from the provided nullable object
`static <T> AnyMSeq<T>`	`ofSeq(java.lang.Object monad)`
`static <T> AnyMValue<T>`	`ofValue(java.lang.Object monad)`
`AnyM<T>`	`peek(java.util.function.Consumer<? super T> c)` Perform a peek operation on the wrapped monad e.g.
`AnyMSeq<T>`	`reduceMSeq(Monoid<AnyMSeq<T>> reducer)`
`AnyMValue<T>`	`reduceMValue(Monoid<AnyMValue<T>> reducer)` Perform a reduction using a Monoid that combines AnyM types.
`static <T1> AnyMValue<ListX<T1>>`	`sequence(java.util.Collection<? extends AnyM<T1>> seq)` Convert a Collection of Monads to a Monad with a List
`static <T> AnyM<java.util.stream.Stream<T>>`	`sequence(java.util.stream.Stream<? extends AnyM<T>> source, java.util.function.Supplier<? extends AnyM<java.util.stream.Stream<T>>> unitEmpty)` Convert a Stream of Monads to a Monad with a Stream
`ReactiveSeq<T>`	`stream()`
`static <T> AnyMSeq<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)
`<NT> ReactiveSeq<NT>`	`toSequence(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends NT>> fn)` Sequence the contents of a Monad.
`java.lang.String`	`toString()`
`static <T,R> AnyMValue<ListX<R>>`	`traverse(java.util.Collection<? extends AnyM<T>> seq, java.util.function.Function<? super T,? extends R> fn)` Convert a Collection of Monads to a Monad with a List applying the supplied function in the process
`static <T,R> AnyM<java.util.stream.Stream<R>>`	`traverse(java.util.stream.Stream<AnyM<T>> source, java.util.function.Supplier<AnyM<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> AnyM<T>`	`unit(T value)` Construct a new instanceof AnyM using the type of the underlying wrapped monad
`<R> R`	`unwrap()` Unwrap a wrapped value

Methods inherited from interface com.aol.cyclops.types.EmptyUnit
emptyUnit

Methods inherited from interface com.aol.cyclops.types.Foldable
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldable, 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.Functor
cast, patternMatch, trampoline

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

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

Method Detail

eqv
```
default boolean eqv(AnyM<T> t)
```

matchable

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

flatMapFirst
```
<R> AnyM<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.

Parameters:

fn - FlatMaping function

Returns:

AnyM with flattening transformation

flatMapFirstPublisher
```
<R> AnyM<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.

Parameters:

fn - FlatMaping function

Returns:

AnyM with flattening transformation

collect
```
<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

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

stream in interface Foldable<T>

Specified by:

stream in interface ToStream<T>

Returns:

SequenceM from this Streamable

toSequence

<NT> ReactiveSeq<NT> toSequence(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends NT>> fn)

Sequence the contents of a Monad. e.g. Turn an

   Optional<List<Integer>>  into Stream<Integer>


 List<Integer> list = AnyM.fromOptional(Optional.of(Arrays.asList(1,2,3,4,5,6)))
                                            .<Integer>toSequence(c->c.stream())
                                            .collect(Collectors.toList());
        
        
        assertThat(list,hasItems(1,2,3,4,5,6));

Returns:: A Sequence that wraps a Stream

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

Unwrap a wrapped value

Specified by:

unwrap in interface Unwrapable

Returns:

wrapped value

filter

AnyM<T> filter(java.util.function.Predicate<? super T> p)

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:: p - Filtering predicate
Returns:: Filtered AnyM

map

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

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 Functor<T>
Parameters:: fn -
Returns:

peek

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

bind
```
<R> AnyM<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.
```
  
 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);
 
 
```
Parameters:

fn - flatMap function

Returns:

flatMapped monad

flatten
```
<T1> AnyM<T1> flatten()
```
join / flatten one level of a nested hierarchy

Specified by:

flatten in interface FlatMap<T>

Returns:

Flattened / joined one level

aggregate

AnyM<java.util.List<T>> aggregate(AnyM<T> next)

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

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

unit
```
<T> AnyM<T> unit(T value)
```
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:

value - to embed inside the monad wrapped by AnyM

Returns:

Newly instantated AnyM

empty

<T> AnyM<T> empty()

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

Returns:: Empty AnyM

reduceMValue

AnyMValue<T> reduceMValue(Monoid<AnyMValue<T>> reducer)

Perform a reduction using a Monoid that combines AnyM types. e.g.

 
   Monoid<AnyMValue<Integer>> optionalAdd = Monoid.of(AnyM.fromOptional(Optional.of(0)), (a,b)-> AnyM.fromOptional(Optional.of(a.get()+b.get())));
			
			AnyM.fromStream(Stream.of(2,8,3,1)).reduceM(optionalAdd);
			
			//AnyM[Optional(14)];

Parameters:: reducer - An identity value (approx. a seed) and BiFunction with a single type to reduce this anyM
Returns:: Reduced AnyM

reduceMSeq

AnyMSeq<T> reduceMSeq(Monoid<AnyMSeq<T>> reducer)

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

toString in class java.lang.Object

Returns:

String representation of this AnyM

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

Parameters:

start - Inclusive start of the range

end - Exclusive end of the range

Returns:

AnyM range

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

Parameters:

start - Inclusive start of the range

end - Exclusive end of the range

Returns:

AnyM range

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

Parameters:

streamable - wrap

Returns:

fromList
```
static <T> AnyMSeq<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

fromSet
```
static <T> AnyMSeq<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:

list - to wrap inside an AnyM

Returns:

AnyM wrapping a Set

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

Parameters:

streamData - values to populate a Stream

Returns:

streamOf
```
static <T> AnyMSeq<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:

fromPublisher

static <T> AnyMSeq<T> fromPublisher(org.reactivestreams.Publisher<T> publisher)

fromStream
```
static <T> AnyMSeq<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<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<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<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<T> fromOptional(java.util.Optional<T> optional)
```
Create an AnyM instance that wraps an Optional

Parameters:

stream - Optional to wrap

Returns:

AnyM that wraps the provided Optonal

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

Parameters:

stream - Optional to wrap

Returns:

AnyM that wraps the provided OptonalDouble

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

Parameters:

stream - OptionalLong to wrap

Returns:

AnyM that wraps the provided OptonalLong

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

Parameters:

stream - OptionalInt to wrap

Returns:

AnyM that wraps the provided OptonalInt

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

Parameters:

stream - CompletableFuture to wrap

Returns:

AnyM that wraps the provided CompletableFuture

fromXor

static <T> AnyMValue<T> fromXor(Xor<?,T> future)

fromFeatureToggle

static <T> AnyMValue<T> fromFeatureToggle(FeatureToggle<T> future)

fromTry

static <T> AnyMValue<T> fromTry(Try<T,?> future)

fromIor

static <T> AnyMValue<T> fromIor(Ior<?,T> future)

fromEval

static <T> AnyMValue<T> fromEval(Eval<T> future)

fromFutureW

static <T> AnyMValue<T> fromFutureW(FutureW<T> future)

fromMaybe

static <T> AnyMValue<T> fromMaybe(Maybe<T> future)

fromEvalTValue

static <T> AnyMValue<T> fromEvalTValue(EvalTValue<T> evalT)

fromMaybeTValue

static <T> AnyMValue<T> fromMaybeTValue(MaybeTValue<T> maybeT)

fromOptionalTValue

static <T> AnyMValue<T> fromOptionalTValue(OptionalTValue<T> optionalT)

fromCompletableFutureTValue

static <T> AnyMValue<T> fromCompletableFutureTValue(CompletableFutureTValue<T> futureT)

fromXorTValue

static <ST,PT> AnyMValue<PT> fromXorTValue(XorTValue<ST,PT> xorT)

fromTryTValue

static <T,X extends java.lang.Throwable> AnyMValue<T> fromTryTValue(TryTValue<T,X> tryT)

fromXorTSeq

static <ST,PT> AnyMSeq<PT> fromXorTSeq(XorTSeq<ST,PT> xorT)

fromTryTSeq

static <T,X extends java.lang.Throwable> AnyMSeq<T> fromTryTSeq(TryTSeq<T,X> tryT)

fromEvalTSeq

static <T> AnyMSeq<T> fromEvalTSeq(EvalTSeq<T> evalT)

fromMaybeTSeq

static <T> AnyMSeq<T> fromMaybeTSeq(MaybeTSeq<T> maybeT)

fromOptionalTSeq

static <T> AnyMSeq<T> fromOptionalTSeq(OptionalTSeq<T> optionalT)

fromCompletableFutureTSeq

static <T> AnyMSeq<T> fromCompletableFutureTSeq(CompletableFutureTSeq<T> futureT)

fromFutureWTValue

static <T> AnyMValue<T> fromFutureWTValue(FutureWTValue<T> futureT)

fromFutureWTSeq

static <T> AnyMSeq<T> fromFutureWTSeq(FutureWTSeq<T> futureT)

fromListT

static <T> AnyMSeq<T> fromListT(ListT<T> listT)

fromStreamT

static <T> AnyMSeq<T> fromStreamT(StreamT<T> streamT)

fromStreamableT

static <T> AnyMSeq<T> fromStreamableT(StreamableT<T> streamT)

fromSetT

static <T> AnyMSeq<T> fromSetT(SetT<T> setT)

fromIterable
```
static <T> AnyMSeq<T> fromIterable(java.lang.Iterable<T> iterable)
```
Create an AnyM instance that wraps an Iterable

Parameters:

stream - Iterable to wrap

Returns:

AnyM that wraps the provided Iterable

fromIterableValue
```
static <T> AnyMValue<T> fromIterableValue(java.lang.Iterable<T> iterable)
```
Use this method to create an AnyMValue from an Iterable. This exists as many monadic value types in Java libraries implement iterable (such as Optional in Javaslang or FunctionalJava).

Parameters:

iterable -

Returns:

ofConvertableValue
```
static <T> AnyMValue<T> ofConvertableValue(java.lang.Object monad)
```
Take the supplied object and always attempt to convert it to a Monad type

Parameters:

monad -

Returns:

ofConvertableSeq

static <T> AnyMSeq<T> ofConvertableSeq(java.lang.Object monad)

ofValue

static <T> AnyMValue<T> ofValue(java.lang.Object monad)

ofSeq

static <T> AnyMSeq<T> ofSeq(java.lang.Object monad)

ofNullable
```
static <T> AnyMValue<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> java.util.List<AnyMSeq<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

listFromStream
```
static <T> java.util.List<AnyMSeq<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> java.util.List<AnyMValue<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> java.util.List<AnyMValue<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

listFromIterable
```
static <T> java.util.List<AnyMSeq<T>> listFromIterable(java.lang.Iterable<java.lang.Iterable<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

listFromXor

static <ST,T> java.util.List<AnyMValue<T>> listFromXor(java.lang.Iterable<Xor<ST,T>> anyM)

listFromIor

static <ST,T> java.util.List<AnyMValue<T>> listFromIor(java.lang.Iterable<Ior<ST,T>> anyM)

listFromMaybe

static <T> java.util.List<AnyMValue<T>> listFromMaybe(java.lang.Iterable<Maybe<T>> anyM)

listFromEval

static <T> java.util.List<AnyMValue<T>> listFromEval(java.lang.Iterable<Eval<T>> anyM)

listFromFutureW

static <T> java.util.List<AnyMValue<T>> listFromFutureW(java.lang.Iterable<FutureW<T>> anyM)

listFromIterator
```
static <T> java.util.List<AnyMSeq<T>> listFromIterator(java.lang.Iterable<java.util.Iterator<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(Arrays.asList(1,2,3).iterator(),Arrays.asList(10,20,30)).iterator(); //List[AnyM[Stream[1,2,3],Stream[10,20,30]]]

Parameters:

anyM - Iterable containing Iterators

Returns:

List of AnyMs

sequence

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

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
See Also:: for helper methods to convert a List of Monads / Collections to List of AnyM

traverse

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

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

traverse

static <T,R> AnyM<java.util.stream.Stream<R>> traverse(java.util.stream.Stream<AnyM<T>> source,
                                                       java.util.function.Supplier<AnyM<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> AnyM<java.util.stream.Stream<T>> sequence(java.util.stream.Stream<? extends AnyM<T>> source,
                                                     java.util.function.Supplier<? extends AnyM<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<AnyM<U>,AnyM<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.

Parameters:

fn -

Returns:

liftM2
```
static <U1,U2,R> java.util.function.BiFunction<AnyM<U1>,AnyM<U2>,AnyM<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<AnyM<Integer>,AnyM<Integer>,AnyM<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.
Parameters:

fn - BiFunction to lift

Returns:

Lifted BiFunction

liftM3
```
static <U1,U2,U3,R> org.jooq.lambda.function.Function3<AnyM<U1>,AnyM<U2>,AnyM<U3>,AnyM<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 <AnyM<Double>,AnyM<Entity>,AnyM<String>,AnyM<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
Parameters:

fn - Function to lift

Returns:

Lifted function

liftM3Cyclops
```
static <U1,U2,U3,R> TriFunction<AnyM<U1>,AnyM<U2>,AnyM<U3>,AnyM<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<AnyM<Double>,AnyM<Entity>,AnyM<String>,AnyM<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
Parameters:

fn - Function to lift

Returns:

Lifted function

liftM4

static <U1,U2,U3,U4,R> org.jooq.lambda.function.Function4<AnyM<U1>,AnyM<U2>,AnyM<U3>,AnyM<U4>,AnyM<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.

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

liftM4Cyclops

static <U1,U2,U3,U4,R> QuadFunction<AnyM<U1>,AnyM<U2>,AnyM<U3>,AnyM<U4>,AnyM<R>> liftM4Cyclops(QuadFunction<? 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

liftM5

static <U1,U2,U3,U4,U5,R> org.jooq.lambda.function.Function5<AnyM<U1>,AnyM<U2>,AnyM<U3>,AnyM<U4>,AnyM<U5>,AnyM<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

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

liftM5Cyclops

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

Lift a QuintFunction (5 parameters) into Monadic form

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

liftM2

static <U1,U2,R> java.util.function.Function<AnyM<U1>,java.util.function.Function<AnyM<U2>,AnyM<R>>> liftM2(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

liftM3

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

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

liftM4

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

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

liftM5

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

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

Interface AnyM<T>

Nested Class Summary

Method Summary

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

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

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

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

Methods inherited from interface java.lang.Iterable

Method Detail

eqv

matchable

flatMapFirst

flatMapFirstPublisher

collect

stream

toSequence

unwrap

filter

map

peek

bind

flatten

aggregate

unit

empty

reduceMValue

reduceMSeq

toString

fromRange

fromRangeLong

fromStreamable

fromList

fromSet

fromArray

streamOf

fromPublisher

fromStream

fromIntStream

fromDoubleStream

fromLongStream

fromOptional

fromOptionalDouble

fromOptionalLong

fromOptionalInt

fromCompletableFuture

fromXor

fromFeatureToggle

fromTry

fromIor

fromEval

fromFutureW

fromMaybe

fromEvalTValue

fromMaybeTValue

fromOptionalTValue

fromCompletableFutureTValue

fromXorTValue

fromTryTValue

fromXorTSeq

fromTryTSeq

fromEvalTSeq

fromMaybeTSeq

fromOptionalTSeq

fromCompletableFutureTSeq

fromFutureWTValue

fromFutureWTSeq

fromListT

fromStreamT

fromStreamableT

fromSetT

fromIterable

fromIterableValue

ofConvertableValue

ofConvertableSeq

ofValue

ofSeq

ofNullable

listFromStreamable

listFromStream

listFromOptional