AnyMValue (cyclops-react 1.0.0-FINAL API)

All Superinterfaces:

AnyM<T>, ApplicativeFunctor<T>, Convertable<T>, ConvertableFunctor<T>, ConvertableToReactiveSeq<T>, EmptyUnit<T>, Filterable<T>, FlatMap<T>, Foldable<T>, Functor<T>, java.lang.Iterable<T>, Matchable.MatchableOptional<T>, Matchable.ValueAndOptionalMatcher<T>, MonadicValue<T>, java.util.function.Predicate<T>, org.reactivestreams.Publisher<T>, java.util.function.Supplier<T>, ToStream<T>, Unit<T>, Unwrapable, Value<T>, Visitable<T>, Zippable<T>

All Known Implementing Classes:

AnyMValueImpl
```
public interface AnyMValue<T>
extends AnyM<T>, Value<T>, Filterable<T>, ApplicativeFunctor<T>, MonadicValue<T>, Matchable.ValueAndOptionalMatcher<T>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface com.aol.cyclops.control.AnyM
  AnyM.AnyMFactory
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor
  ApplicativeFunctor.Applicatives, ApplicativeFunctor.ApplyFunctions<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.Value
  Value.ValueImpl<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.Convertable
  Convertable.SupplierToConvertable<T>

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`AnyMValue<java.util.List<T>>`	`aggregate(AnyM<T> next)` Aggregate the contents of this Monad and the supplied Monad
`<R> AnyMValue<R>`	`applyM(AnyMValue<java.util.function.Function<? super T,? extends R>> fn)` Apply function/s inside supplied Monad to data in current Monad e.g.
`<R> AnyMValue<R>`	`bind(java.util.function.Function<? super T,?> fn)` Perform a looser typed flatMap / bind operation The return type can be another type other than the host type Note the modified javaslang monad laws are not applied during the looser typed bind operation The modification being used to work around the limits of the Java type system.
`default <U> AnyMValue<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default <R> AnyMValue<R>`	`coflatMap(java.util.function.Function<? super MonadicValue<T>,R> mapper)`
`default <R,A> R`	`collect(java.util.stream.Collector<? super T,A,R> collector)` Collect the contents of the monad wrapped by this AnyM into supplied collector A mutable reduction operation equivalent to Stream#collect
`default AnyMValue<T>`	`combine(Monoid<T> monoid, AnyMValue<? extends T> v2)`
`default <T2,R> AnyMValue<R>`	`combine(Value<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)` Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction
`<T> AnyMValue<T>`	`empty()` Construct an AnyM wrapping a new empty instance of the wrapped type e.g.
`<T> AnyMValue<T>`	`emptyUnit()`
`default boolean`	`eqv(AnyMValue<T> t)` Equivalence test
`AnyMValue<T>`	`filter(java.util.function.Predicate<? super T> p)` Perform a filter operation on the wrapped monad instance e.g.
`default AnyMValue<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<R> AnyMValue<R>`	`flatMap(java.util.function.Function<? super T,? extends AnyMValue<? extends R>> fn)` flatMap operation AnyM follows the javaslang modified 'monad' laws https://gist.github.com/danieldietrich/71be006b355d6fbc0584 In particular left-identity becomes Left identity: unit(a).flatMap(f) ≡ select(f.apply(a)) Or in plain English, if your flatMap function returns multiple values (such as flatMap by Stream) but the current Monad only can only hold one value, only the first value is accepted.
`<R> AnyMValue<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> AnyMValue<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> AnyMValue<T1>`	`flatten()` join / flatten one level of a nested hierarchy
`<R1,R> AnyMValue<R>`	`forEach2(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied monad (allowing null handling, exception handling etc to be injected, for example)
`<R1,R> AnyMValue<R>`	`forEach2(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied monad (allowing null handling, exception handling etc to be injected, for example)
`<R1,R2,R> AnyMValue<R>`	`forEach3(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyMValue<R2>>> monad2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)` Perform a three level nested internal iteration over this AnyM and the supplied monads
`<R1,R2,R> AnyMValue<R>`	`forEach3(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyMValue<R2>>> monad2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`default java.util.Iterator<T>`	`iterator()`
`static <U,R> java.util.function.Function<AnyMValue<U>,AnyMValue<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<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<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<AnyMValue<U1>,java.util.function.Function<AnyMValue<U2>,AnyMValue<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<AnyMValue<U1>,java.util.function.Function<AnyMValue<U2>,java.util.function.Function<AnyMValue<U3>,AnyMValue<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<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<U3>,AnyMValue<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<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<U3>,AnyMValue<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<AnyMValue<U1>,java.util.function.Function<AnyMValue<U2>,java.util.function.Function<AnyMValue<U3>,java.util.function.Function<AnyMValue<U4>,AnyMValue<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<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<U3>,AnyMValue<U4>,AnyMValue<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<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<U3>,AnyMValue<U4>,AnyMValue<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<AnyMValue<U1>,java.util.function.Function<AnyMValue<U2>,java.util.function.Function<AnyMValue<U3>,java.util.function.Function<AnyMValue<U4>,java.util.function.Function<AnyMValue<U5>,AnyMValue<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<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<U3>,AnyMValue<U4>,AnyMValue<U5>,AnyMValue<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<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<U3>,AnyMValue<U4>,AnyMValue<U5>,AnyMValue<R>>`	`liftM5Cyclops(QuintFunction<? super U1,? super U2,? super U3,? super U4,? super U5,? extends R> fn)` Lift a QuintFunction (5 parameters) into Monadic form
`<R> AnyMValue<R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Perform a map operation on the wrapped monad instance e.g.
`default java.lang.String`	`mkString()`
`default AnyMValue<MonadicValue<T>>`	`nest()`
`default AnyMValue<T>`	`notNull()` Filter elements retaining only values which are not null
`default <U> AnyMValue<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`default <R> AnyMValue<R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`AnyMValue<T>`	`peek(java.util.function.Consumer<? super T> c)` Perform a peek operation on the wrapped monad e.g.
`AnyM<java.util.List<T>>`	`replicateM(int times)` Replicate given Monad
`static <T1> AnyMValue<ListX<T1>>`	`sequence(java.util.Collection<? extends AnyMValue<T1>> seq)` Convert a Collection of Monads to a Monad with a List
`static <T> AnyMValue<java.util.stream.Stream<T>>`	`sequence(java.util.stream.Stream<AnyMValue<T>> source, java.util.function.Supplier<AnyMValue<java.util.stream.Stream<T>>> unitEmpty)` Convert a Stream of Monads to a Monad with a Stream
`ReactiveSeq<T>`	`stream()`
`default Value<T>`	`toFirstValue()`
`<NT> ReactiveSeq<NT>`	`toReactiveSeq(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends NT>> fn)` Sequence the contents of a Monad.
`<T> ReactiveSeq<T>`	`toSequence()` `Optional<List<Integer>> into Stream<Integer>`
`default <R> AnyMValue<R>`	`trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`static <T,R> AnyMValue<ListX<R>>`	`traverse(java.util.Collection<? extends AnyMValue<T>> seq, java.util.function.Function<? super T,? extends R> fn)` Convert a Stream of Monads to a Monad with a List applying the supplied function in the process
`static <T,R> AnyMValue<java.util.stream.Stream<R>>`	`traverse(java.util.stream.Stream<AnyMValue<T>> source, java.util.function.Supplier<AnyMValue<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> AnyMValue<T>`	`unit(T value)` Construct a new instanceof AnyM using the type of the underlying wrapped monad
`default <T2,R> AnyMValue<R>`	`zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> app)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`default <T2,R> AnyMValue<R>`	`zip(java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)` Zip (combine) this Zippable with the supplied Iterable using the supplied combining function

Methods inherited from interface com.aol.cyclops.control.AnyM
eqv, fromArray, fromCompletableFuture, fromCompletableFutureTSeq, fromCompletableFutureTValue, fromDoubleStream, fromEval, fromEvalTSeq, fromEvalTValue, fromFeatureToggle, fromFutureW, fromFutureWTSeq, fromFutureWTValue, fromIntStream, fromIor, fromIterable, fromIterableValue, fromList, fromListT, fromLongStream, fromMaybe, fromMaybeTSeq, fromMaybeTValue, fromOptional, fromOptionalDouble, fromOptionalInt, fromOptionalLong, fromOptionalTSeq, fromOptionalTValue, fromPublisher, fromRange, fromRangeLong, fromSet, fromSetT, fromStream, fromStreamable, fromStreamableT, fromStreamT, fromTry, fromTryTSeq, fromTryTValue, fromXor, fromXorTSeq, fromXorTValue, liftM3, liftM4, liftM5, listFromCompletableFuture, listFromEval, listFromFutureW, listFromIor, listFromIterable, listFromIterator, listFromMaybe, listFromOptional, listFromStream, listFromStreamable, listFromXor, matchable, ofConvertableSeq, ofConvertableValue, ofNullable, ofSeq, ofValue, reduceMSeq, reduceMValue, sequence, sequence, streamOf, toString, traverse, traverse, unwrap

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

Methods inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor
applyFunctions

Methods inherited from interface com.aol.cyclops.types.Value
fold, fold, generate, iterate, newSubscriber, of, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFeatureToggle, toFutureStream, toFutureStream, toIor, toLazyImmutable, toListX, toMaybe, toMutable, toPBagX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toTry, toTry, toTry, toXor, toXor, unapply

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, 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.Convertable
collect, fromSupplier, get, isPresent, orElse, orElseGet, orElseThrow, toAtomicReference, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFutureW, toFutureWAsync, toFutureWAsync, toOptional, toOptionalAtomicReference, toStream

Methods inherited from interface java.util.function.Predicate
and, isEqual, negate, or

Methods inherited from interface com.aol.cyclops.types.Zippable
zip, zip, zip, zip, zip

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

Methods inherited from interface com.aol.cyclops.types.MonadicValue
anyM

Methods inherited from interface com.aol.cyclops.control.Matchable.ValueAndOptionalMatcher
toOptional, visit

Methods inherited from interface com.aol.cyclops.control.Matchable.MatchableOptional
matches

Method Detail

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

collect
```
default <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
```
Description copied from interface: AnyM
Collect the contents of the monad wrapped by this AnyM into supplied collector 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());
      
 
 
```
Specified by:

collect in interface AnyM<T>

Specified by:

collect in interface Convertable<T>

Specified by:

collect in interface Value<T>

Parameters:

collector - JDK collector to perform mutable reduction

Returns:

Reduced value

combine
```
default <T2,R> AnyMValue<R> combine(Value<? extends T2> app,
                                    java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
```
Description copied from interface: ApplicativeFunctor

Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction

Specified by:

combine in interface ApplicativeFunctor<T>

Parameters:

app - Value to combine with this one.

fn - BiFunction to combine them

Returns:

New Applicativefunctor that represents the combined values

zip
```
default <T2,R> AnyMValue<R> zip(java.lang.Iterable<? extends T2> app,
                                java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
```
Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Iterable using the supplied combining function

Specified by:

zip in interface ApplicativeFunctor<T>

Specified by:

zip in interface Zippable<T>

Parameters:

app - to zip with

fn - Zip function

Returns:

Combined zippable

zip
```
default <T2,R> AnyMValue<R> zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn,
                                org.reactivestreams.Publisher<? extends T2> app)
```
Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function

Specified by:

zip in interface ApplicativeFunctor<T>

Specified by:

zip in interface Zippable<T>

Parameters:

fn - Zip / combining function

app - to combine with

Returns:

Combined zippable

flatMapFirst
```
<R> AnyMValue<R> flatMapFirst(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)
```
Description copied from interface: AnyM

Perform a flatMap operation that will only work as normal for AnyMSeq types, but for AnyMValue (which can only hold a single value) will take the first value from the Iterable returned.

Specified by:

flatMapFirst in interface AnyM<T>

Parameters:

fn - FlatMaping function

Returns:

AnyM with flattening transformation

flatMapFirstPublisher
```
<R> AnyMValue<R> flatMapFirstPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
Description copied from interface: AnyM

Perform a flatMap operation that will only work as normal for AnyMSeq types, but for AnyMValue (which can only hold a single value) will take the first value from the Publisher returned.

Specified by:

flatMapFirstPublisher in interface AnyM<T>

Parameters:

fn - FlatMaping function

Returns:

AnyM with flattening transformation

coflatMap

default <R> AnyMValue<R> coflatMap(java.util.function.Function<? super MonadicValue<T>,R> mapper)

Specified by:: coflatMap in interface MonadicValue<T>

nest
```
default AnyMValue<MonadicValue<T>> nest()
```
Specified by:

nest in interface MonadicValue<T>

combine

default AnyMValue<T> combine(Monoid<T> monoid,
                             AnyMValue<? extends T> v2)

mkString
```
default java.lang.String mkString()
```
Specified by:

mkString in interface Value<T>

toFirstValue
```
default Value<T> toFirstValue()
```

ofType

default <U> AnyMValue<U> ofType(java.lang.Class<? extends U> type)

Description copied from interface: Filterable

Keep only those elements in a stream that are of a given type.

  
 
 // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)

Specified by:: ofType in interface Filterable<T>

filterNot
```
default AnyMValue<T> filterNot(java.util.function.Predicate<? super T> fn)
```
Description copied from interface: Filterable
Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[1,2]
   
 
 
```
Specified by:

filterNot in interface Filterable<T>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filterable with elements removed where the predicate does not hold

notNull
```
default AnyMValue<T> notNull()
```
Description copied from interface: Filterable
Filter elements retaining only values which are not null
```
  
 
   of(1,2,null,4).nonNull();
 
   //[1,2,4]
   
 
```
Specified by:

notNull in interface Filterable<T>

Returns:

Filterable with nulls removed

cast
```
default <U> AnyMValue<U> cast(java.lang.Class<? extends U> type)
```
Description copied from interface: Functor

Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)

Specified by:

cast in interface Functor<T>

trampoline

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

Description copied from interface: Functor

Performs a map operation that can call a recursive method without running out of stack space

 
 ReactiveSeq.of(10,20,30,40)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println); 
    			 
    	Trampoline<Long> fibonacci(int i){
    		return fibonacci(i,1,0);
    	}
    	Trampoline<Long> fibonacci(int n, long a, long b) {
        	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
    	}		 
    			 
 55
    	6765
    	832040
    	102334155
 
 
 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);
    			 
    			 
 completes successfully

Specified by:: trampoline in interface Functor<T>
Parameters:: mapper - TCO Transformation function
Returns:: Functor transformed by the supplied transformation function

patternMatch

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

Description copied from interface: Functor

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

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

Specified by:: patternMatch in interface Functor<T>
Parameters:: case1 - Function to generate a case (or chain of cases as a single case); otherwise - Value if supplied case doesn't match
Returns:: CollectionX where elements are transformed by pattern matching

emptyUnit
```
<T> AnyMValue<T> emptyUnit()
```
Specified by:

emptyUnit in interface EmptyUnit<T>

replicateM

AnyM<java.util.List<T>> replicateM(int times)

Replicate given Monad

 
  
   AnyM<Optional<Integer>> applied =AnyM.fromOptional(Optional.of(2)).replicateM(5);
   
      //AnyM[Optional[List(2,2,2,2,2)]]

Parameters:: times - number of times to replicate
Returns:: Replicated Monad

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

stream in interface AnyM<T>

Specified by:

stream in interface Foldable<T>

Specified by:

stream in interface ToStream<T>

Specified by:

stream in interface Value<T>

Returns:

SequenceM from this Streamable

filter

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

Description copied from interface: AnyM

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

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

Specified by:: filter in interface AnyM<T>
Specified by:: filter in interface Filterable<T>
Parameters:: p - Filtering predicate
Returns:: Filtered AnyM

map
```
<R> AnyMValue<R> map(java.util.function.Function<? super T,? extends R> fn)
```
Description copied from interface: AnyM
Perform a map operation on the wrapped monad instance e.g.
```
  
   AnyM.fromIterable(Try.runWithCatch(this::loadData))
   	 .map(data->transform(data))		
   
   AnyM.fromStream(Stream.of(1,2,3))
       .map(i->i+2);
   
   //AnyM[Stream[3,4,5]]
 
 
```
Specified by:

map in interface AnyM<T>

Specified by:

map in interface ConvertableFunctor<T>

Specified by:

map in interface Functor<T>

Specified by:

map in interface MonadicValue<T>

Parameters:

fn - Mapping function

Returns:

AnyM transformed by the mapping function

peek
```
AnyMValue<T> peek(java.util.function.Consumer<? super T> c)
```
Description copied from interface: AnyM
Perform a peek operation on the wrapped monad e.g.
```
  
   AnyM.fromCompletableFuture(CompletableFuture.supplyAsync(()->loadData())
       .peek(System.out::println)
 
 
```
Specified by:

peek in interface AnyM<T>

Specified by:

peek in interface Functor<T>

Parameters:

c - Consumer to accept current data

Returns:

AnyM after peek operation

bind
```
<R> AnyMValue<R> bind(java.util.function.Function<? super T,?> fn)
```
Description copied from interface: AnyM
Perform a looser typed flatMap / bind operation The return type can be another type other than the host type Note the modified javaslang monad laws are not applied during the looser typed bind operation The modification being used to work around the limits of the Java type system.
```
  
 AnyM<List<Integer>> m  = AnyM.fromStream(Stream.of(Arrays.asList(1,2,3),Arrays.asList(1,2,3)));
       AnyM<Integer> intM = m.bind(Collection::stream);
 
 
```
Specified by:

bind in interface AnyM<T>

Parameters:

fn - flatMap function

Returns:

flatMapped monad

flatten
```
<T1> AnyMValue<T1> flatten()
```
Description copied from interface: AnyM

join / flatten one level of a nested hierarchy

Specified by:

flatten in interface AnyM<T>

Specified by:

flatten in interface FlatMap<T>

Returns:

Flattened / joined one level

aggregate

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

Description copied from interface: AnyM

Aggregate the contents of this Monad and the supplied Monad

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

Specified by:: aggregate in interface AnyM<T>
Parameters:: next - Monad to aggregate content with
Returns:: Aggregated Monad

traverse

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

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

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

Parameters:: seq - Stream of Monads; fn - Function to apply
Returns:: Monad with a list

traverse

static <T,R> AnyMValue<java.util.stream.Stream<R>> traverse(java.util.stream.Stream<AnyMValue<T>> source,
                                                            java.util.function.Supplier<AnyMValue<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> AnyMValue<java.util.stream.Stream<T>> sequence(java.util.stream.Stream<AnyMValue<T>> source,
                                                          java.util.function.Supplier<AnyMValue<java.util.stream.Stream<T>>> unitEmpty)

Convert a Stream of Monads to a Monad with a Stream

sequence

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

Convert a Collection of Monads to a Monad with a List

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

forEach2

<R1,R> AnyMValue<R> forEach2(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad,
                             java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)

Perform a two level nested internal iteration over this Stream and the supplied monad (allowing null handling, exception handling etc to be injected, for example)

  
 AnyM.fromArray(1,2,3)
    					.forEachAnyM2(a->AnyM.fromIntStream(IntStream.range(10,13)),
    								a->b->a+b);
    								
 
  //AnyM[11,14,12,15,13,16]

Parameters:: monad - Nested Monad to iterate over; yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
Returns:: LazyFutureStream with elements generated via nested iteration

forEach2

<R1,R> AnyMValue<R> forEach2(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad,
                             java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction,
                             java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)

Perform a two level nested internal iteration over this Stream and the supplied monad (allowing null handling, exception handling etc to be injected, for example)

  
 AnyM.fromArray(1,2,3)
    					.forEach2(a->AnyM.fromIntStream(IntStream.range(10,13)),
    					            a->b-> a<3 && b>10,
    								a->b->a+b);
    								
 
  //AnyM[14,15]

Parameters:: monad - Nested Monad to iterate over; filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function; yieldingFunction - Function with pointers to the current element from both monads that generates the new elements
Returns:

forEach3

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

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

  
 AnyM.fromArray(1,2)
    					.forEach2(a->AnyM.fromIntStream(IntStream.range(10,13)),
    					(a->b->AnyM.fromArray(""+(a+b),"hello world"),
    								a->b->c->c+":"a+":"+b);
    								
 
  //AnyM[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]

Parameters:: monad1 - Nested monad to flatMap over; stream2 - Nested monad to flatMap over; filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function; yieldingFunction - Function with pointers to the current element from both monads that generates the new elements
Returns:: AnyM with elements generated via nested iteration

forEach3

<R1,R2,R> AnyMValue<R> forEach3(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad1,
                                java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyMValue<R2>>> monad2,
                                java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)

Perform a three level nested internal iteration over this AnyM and the supplied monads

  
 AnyM.fromArray(1,2,3)
    				.forEach3(a->AnyM.fromStream(IntStream.range(10,13)),
    					 a->b->AnyM.fromArray(""+(a+b),"hello world"),
    				         a->b->c-> c!=3,
    							a->b->c->c+":"a+":"+b);
    							
 
  //SequenceM[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]

Parameters:: monad1 - Nested Stream to iterate over; monad2 - Nested Stream to iterate over; yieldingFunction - Function with pointers to the current element from both Monads that generates the new elements
Returns:: AnyM with elements generated via nested iteration

flatMap
```
<R> AnyMValue<R> flatMap(java.util.function.Function<? super T,? extends AnyMValue<? extends R>> fn)
```
flatMap operation AnyM follows the javaslang modified 'monad' laws https://gist.github.com/danieldietrich/71be006b355d6fbc0584 In particular left-identity becomes Left identity: unit(a).flatMap(f) ≡ select(f.apply(a)) Or in plain English, if your flatMap function returns multiple values (such as flatMap by Stream) but the current Monad only can only hold one value, only the first value is accepted. Example 1 : multi-values are supported (AnyM wraps a Stream, List, Set etc)
```
  
   AnyM<Integer> anyM = AnyM.fromStream(Stream.of(1,2,3)).flatMap(i->AnyM.fromArray(i+1,i+2));
   
   //AnyM[Stream[2,3,3,4,4,5]]
 
 
```
Example 2 : multi-values are not supported (AnyM wraps a Stream, List, Set etc)
```
  
   AnyM<Integer> anyM = AnyM.fromOptional(Optional.of(1)).flatMap(i->AnyM.fromArray(i+1,i+2));
   
   //AnyM[Optional[2]]
 
 
```
Parameters:

fn - flatMap function

Returns:

flatMapped AnyM

applyM

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

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

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

with Optionals


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

Parameters:: fn -
Returns:

toReactiveSeq

<NT> ReactiveSeq<NT> toReactiveSeq(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));

Specified by:: toReactiveSeq in interface AnyM<T>
Parameters:: fn - Function used to convert contents to Stream
Returns:: A Sequence that wraps a Stream

toSequence

<T> ReactiveSeq<T> toSequence()

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

Less type safe equivalent, but may be more accessible than toSequence(fn) i.e.

  
    toSequence(Function<T,Stream<NT>> fn)


 List<Integer> list = anyM(Optional.of(Arrays.asList(1,2,3,4,5,6)))
                                            .<Integer>toSequence()
                                            .collect(Collectors.toList());

Returns:: A Sequence that wraps a Stream

unit
```
<T> AnyMValue<T> unit(T value)
```
Description copied from interface: AnyM
Construct a new instanceof AnyM using the type of the underlying wrapped monad
```
 
   AnyM<Integer> ints = AnyM.fromList(Arrays.asList(1,2,3);
   AnyM<String> string = ints.unit("hello");
 
 
```
Specified by:

unit in interface AnyM<T>

Specified by:

unit in interface MonadicValue<T>

Specified by:

unit in interface Unit<T>

Parameters:

value - to embed inside the monad wrapped by AnyM

Returns:

Newly instantated AnyM

empty
```
<T> AnyMValue<T> empty()
```
Description copied from interface: AnyM
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();
 
 
```
Specified by:

empty in interface AnyM<T>

Returns:

Empty AnyM

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

iterator in interface Convertable<T>

Specified by:

iterator in interface java.lang.Iterable<T>

Specified by:

iterator in interface Matchable.MatchableOptional<T>

Specified by:

iterator in interface Matchable.ValueAndOptionalMatcher<T>

Specified by:

iterator in interface ToStream<T>

Specified by:

iterator in interface Value<T>

liftM
```
static <U,R> java.util.function.Function<AnyMValue<U>,AnyMValue<R>> liftM(java.util.function.Function<? super U,? extends R> fn)
```
Lift a function so it accepts an AnyM and returns an AnyM (any monad) AnyM view simplifies type related challenges.

Specified by:

liftM in interface AnyM<T>

Parameters:

fn -

Returns:

liftM2
```
static <U1,U2,R> java.util.function.BiFunction<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<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<AnyMValue<Integer>,AnyMValue<Integer>,AnyMValue<Integer>> add = Monads.liftM2(this::add);
   
  Optional<Integer> result = add.apply(getBase(),getIncrease());
  
   private Integer add(Integer a, Integer b){
    			return a+b;
    	}
 
```
The add method has no null handling, but we can lift the method to Monadic form, and use Optionals to automatically handle null / empty value cases.
Specified by:

liftM2 in interface AnyM<T>

Parameters:

fn - BiFunction to lift

Returns:

Lifted BiFunction

liftM3
```
static <U1,U2,U3,R> org.jooq.lambda.function.Function3<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<U3>,AnyMValue<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 <AnyMValue<Double>,AnyMValue<Entity>,AnyMValue<String>,AnyMValue<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<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<U3>,AnyMValue<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<AnyMValue<Double>,AnyMValue<Entity>,AnyMValue<String>,AnyMValue<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<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<U3>,AnyMValue<U4>,AnyMValue<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<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<U3>,AnyMValue<U4>,AnyMValue<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<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<U3>,AnyMValue<U4>,AnyMValue<U5>,AnyMValue<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<AnyMValue<U1>,AnyMValue<U2>,AnyMValue<U3>,AnyMValue<U4>,AnyMValue<U5>,AnyMValue<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<AnyMValue<U1>,java.util.function.Function<AnyMValue<U2>,AnyMValue<R>>> liftM2(java.util.function.Function<U1,java.util.function.Function<U2,R>> fn)

Lift a Curried Function into Monadic form

Specified by:: liftM2 in interface AnyM<T>
Parameters:: fn - Function to lift
Returns:: Lifted function

liftM3

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

Lift a Curried Function into Monadic form

Specified by:: liftM3 in interface AnyM<T>
Parameters:: fn - Function to lift
Returns:: Lifted function

liftM4

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

Lift a Curried Function into Monadic form

Specified by:: liftM4 in interface AnyM<T>
Parameters:: fn - Function to lift
Returns:: Lifted function

liftM5

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

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

Specified by:: liftM5 in interface AnyM<T>
Parameters:: fn - Function to lift
Returns:: Lifted function

Interface AnyMValue<T>

Nested Class Summary

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

Nested classes/interfaces inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor

Nested classes/interfaces inherited from interface com.aol.cyclops.types.Value

Nested classes/interfaces inherited from interface com.aol.cyclops.types.Convertable

Method Summary

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

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

Methods inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor

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

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

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

Methods inherited from interface java.util.function.Predicate

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

Methods inherited from interface java.lang.Iterable

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

Methods inherited from interface com.aol.cyclops.control.Matchable.ValueAndOptionalMatcher

Methods inherited from interface com.aol.cyclops.control.Matchable.MatchableOptional

Method Detail

eqv

collect

combine

zip

zip

flatMapFirst

flatMapFirstPublisher

coflatMap

nest

combine

mkString

toFirstValue

ofType

filterNot

notNull

cast

trampoline

patternMatch

emptyUnit

replicateM

stream

filter

map

peek

bind

flatten

aggregate

traverse

traverse

sequence

sequence

forEach2

forEach2

forEach3

forEach3

flatMap

applyM

toReactiveSeq

toSequence

unit

empty

iterator

liftM

liftM2

liftM3

liftM3Cyclops

liftM4

liftM4Cyclops

liftM5

liftM5Cyclops

liftM2

liftM3

liftM4

liftM5