AnyMValueImpl (simple-react 1.0.0-RC2.2 API)

java.lang.Object
- com.aol.cyclops.internal.monads.BaseAnyMImpl<T>
- - com.aol.cyclops.internal.monads.AnyMValueImpl<T>

All Implemented Interfaces:

AnyM<T>, Matchable<T>, Matchable.MatchableOptional<T>, Matchable.ValueAndOptionalMatcher<T>, AnyMValue<T>, Applicativable<T>, Convertable<T>, ConvertableFunctor<T>, EmptyUnit<T>, Filterable<T>, FlatMap<T>, Foldable<T>, Functor<T>, ConvertableToReactiveSeq<T>, ToStream<T>, Unit<T>, Unwrapable, Value<T>, java.lang.Iterable<T>, java.util.function.Predicate<T>, java.util.function.Supplier<T>, org.reactivestreams.Publisher<T>
```
public class AnyMValueImpl<T>
extends BaseAnyMImpl<T>
implements AnyMValue<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.Applicativable
  Applicativable.Applicatives, Applicativable.SemigroupApplyer<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.Value
  Value.ValueImpl<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops.control.Matchable
  Matchable.AsMatchable, Matchable.AutoCloseableMatchableIterable<TYPE>, Matchable.CheckValue1<T,R>, Matchable.CheckValue2<T1,T2,R>, Matchable.CheckValue3<T1,T2,T3,R>, Matchable.CheckValue4<T1,T2,T3,T4,R>, Matchable.CheckValue5<T1,T2,T3,T4,T5,R>, Matchable.CheckValueOpt<T,R>, Matchable.CheckValues<T,R>, Matchable.MatchableIterable<TYPE>, Matchable.MatchableObject<TYPE>, Matchable.MatchableOptional<T>, Matchable.MatchSelf<TYPE>, Matchable.MTuple1<T1>, Matchable.MTuple2<T1,T2>, Matchable.MTuple3<T1,T2,T3>, Matchable.MTuple4<T1,T2,T3,T4>, Matchable.MTuple5<T1,T2,T3,T4,T5>, Matchable.MXor<T1,T2>, Matchable.ValueAndOptionalMatcher<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.Convertable
  Convertable.SupplierToConvertable<T>

Field Summary
- Fields inherited from class com.aol.cyclops.internal.monads.BaseAnyMImpl
  initialType, monad

Constructor Summary

Constructors
Constructor and Description

AnyMValueImpl(Monad<T> monad, java.lang.Class initialType)

Constructors
Constructor and Description
`AnyMValueImpl(Monad<T> monad, java.lang.Class initialType)`

Method Summary

All Methods Instance Methods Concrete 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.
`<T> AnyMValue<T>`	`empty()` Construct an AnyM wrapping an empty instance of the wrapped type e.g.
`<T> AnyMValue<T>`	`emptyUnit()`
`boolean`	`equals(java.lang.Object obj)`
`AnyMValue<T>`	`filter(java.util.function.Predicate<? super T> p)` Perform a filter operation on the wrapped monad instance 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.
`<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
`T`	`get()`
`T`	`getMatchable()`
`int`	`hashCode()`
`<R> AnyMValue<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()`
`AnyMValue<T>`	`peek(java.util.function.Consumer<? super T> c)` Perform a peek operation on the wrapped monad e.g.
`ReactiveSeq<T>`	`reactiveSeq()`
`AnyMValue<java.util.List<T>>`	`replicateM(int times)` Replicate given Monad
`ReactiveSeq<T>`	`stream()`
`<NT> ReactiveSeq<NT>`	`toSequence()` `Optional<List<Integer>> into Stream<Integer>`
`<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()`
`<T> AnyMValue<T>`	`unit(T value)` Construct a new instanceof AnyM using the type of the underlying wrapped monad
`<T> T`	`unwrap()`

Methods inherited from class com.aol.cyclops.internal.monads.BaseAnyMImpl
asSequence, bindInternal, filterInternal, flatMapInternal, flattenInternal, forEach, mapInternal, monad, peekInternal, reduceMSeq, reduceMValue, toList, toSet

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.aol.cyclops.types.anyM.AnyMValue
cast, collect, filterNot, iterator, liftM, liftM2, liftM2, liftM3, liftM3, liftM3Cyclops, liftM4, liftM4, liftM4Cyclops, liftM5, liftM5, liftM5Cyclops, mkString, notNull, ofType, patternMatch, sequence, sequence, toFirstValue, trampoline, traverse

Methods inherited from interface com.aol.cyclops.control.AnyM
fromArray, fromCollection, fromCompletableFuture, fromDoubleStream, fromEval, fromFeatureToggle, fromFile, fromFutureW, fromIntStream, fromIor, fromIterable, fromList, fromLongStream, fromMaybe, fromOptional, fromOptionalDouble, fromOptionalInt, fromOptionalLong, fromRange, fromRangeLong, fromSet, fromStream, fromStreamable, fromTry, fromURL, fromXor, listFromCollection, listFromCompletableFuture, listFromEval, listFromFutureW, listFromIor, listFromIterable, listFromIterator, listFromMaybe, listFromOptional, listFromStream, listFromStreamable, listFromXor, ofConvertableSeq, ofConvertableValue, ofNullable, ofSeq, ofValue, reduceMSeq, reduceMValue, sequence, sequence, streamOf, traverse, traverse

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

Methods inherited from interface com.aol.cyclops.types.applicative.Applicativable
ap, ap, ap1, ap2, ap3, ap4, ap5

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

Methods inherited from interface com.aol.cyclops.types.Foldable
foldRight, foldRight, foldRight, foldRightMapToType, join, join, join, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce

Methods inherited from interface com.aol.cyclops.control.Matchable
from, from, from, from, from, from, from, from, from, from, fromCharSequence, listOfValues, ofDecomposable, otherwise, otherwise, then, then, when, when, when, when, when, when, when, when, when, when, whenGuard, whenTrue, whenValues

Methods inherited from interface com.aol.cyclops.types.Convertable
fromSupplier, orElse, orElseGet, orElseThrow, toAtomicReference, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFutureW, toList, toOptional, toOptionalAtomicReference, toStream, visit

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

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

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

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

- Constructor Detail
  - AnyMValueImpl
```
public AnyMValueImpl(Monad<T> monad,
                     java.lang.Class initialType)
```
- Method Detail
  - matchable
```
public Xor<AnyMValue<T>,AnyMSeq<T>> matchable()
```
    Specified by:
    
    matchable in interface AnyM<T>
  - reactiveSeq
```
public ReactiveSeq<T> reactiveSeq()
```
    Specified by:
    
    reactiveSeq in interface ConvertableToReactiveSeq<T>
    
    Specified by:
    
    reactiveSeq in interface ToStream<T>
  - get
```
public T get()
```
    Specified by:
    
    get in interface Convertable<T>
    
    Specified by:
    
    get in interface java.util.function.Supplier<T>
    
    Overrides:
    
    get in class BaseAnyMImpl<T>
    
    Returns:
    
    Contained value, maybe null
  - emptyUnit
```
public <T> AnyMValue<T> emptyUnit()
```
    Specified by:
    
    emptyUnit in interface AnyMValue<T>
    
    Specified by:
    
    emptyUnit in interface EmptyUnit<T>
  - replicateM
```
public AnyMValue<java.util.List<T>> replicateM(int times)
```
    Description copied from interface: AnyMValue
    Replicate given Monad
```
 
  
   AnyM<Optional<Integer>> applied =AnyM.fromOptional(Optional.of(2)).replicateM(5);
   
         //AnyM[Optional[List(2,2,2,2,2)]]
         
         
```
    Specified by:
    
    replicateM in interface AnyMValue<T>
    
    Parameters:
    
    times - number of times to replicate
    
    Returns:
    
    Replicated Monad
  - filter
```
public 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 AnyMValue<T>
    
    Specified by:
    
    filter in interface Filterable<T>
    
    Parameters:
    
    p - Filtering predicate
    
    Returns:
    
    Filtered AnyM
  - peek
```
public 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 AnyMValue<T>
    
    Specified by:
    
    peek in interface Functor<T>
    
    Parameters:
    
    c - Consumer to accept current data
    
    Returns:
    
    AnyM after peek operation
  - aggregate
```
public AnyMValue<java.util.List<T>> aggregate(AnyM<T> next)
```
    Description copied from class: BaseAnyMImpl
    Aggregate the contents of this Monad and the supplied Monad
```
 
 
 List<Integer> result = anyM(Stream.of(1,2,3,4))
 							.aggregate(anyM(Optional.of(5)))
 							.asSequence()
 							.toList();
		
		assertThat(result,equalTo(Arrays.asList(1,2,3,4,5)));
		
```
    Specified by:
    
    aggregate in interface AnyM<T>
    
    Specified by:
    
    aggregate in interface AnyMValue<T>
    
    Overrides:
    
    aggregate in class BaseAnyMImpl<T>
    
    Parameters:
    
    next - Monad to aggregate content with
    
    Returns:
    
    Aggregated Monad
  - unit
```
public <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 AnyMValue<T>
    
    Specified by:
    
    unit in interface Unit<T>
    
    Specified by:
    
    unit in class BaseAnyMImpl<T>
    
    Parameters:
    
    value - to embed inside the monad wrapped by AnyM
    
    Returns:
    
    Newly instantated AnyM
  - empty
```
public <T> AnyMValue<T> empty()
```
    Description copied from interface: AnyM
    Construct an AnyM wrapping an empty instance of the wrapped type e.g.
```
  
 Any<Integer> ints = AnyM.fromStream(Stream.of(1,2,3));
 AnyM<Integer> empty=ints.empty();
 
 
```
    Specified by:
    
    empty in interface AnyM<T>
    
    Specified by:
    
    empty in interface AnyMValue<T>
    
    Specified by:
    
    empty in class BaseAnyMImpl<T>
    
    Returns:
    
    Empty AnyM
  - toSequence
```
public <NT> ReactiveSeq<NT> toSequence(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends NT>> fn)
```
    Description copied from class: BaseAnyMImpl
    Sequence the contents of a Monad. e.g. Turn an
```
         Optional<List<Integer>>  into Stream<Integer> 
```
```
 List<Integer> list = anyM(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:
    
    toSequence in interface AnyM<T>
    
    Specified by:
    
    toSequence in interface AnyMValue<T>
    
    Overrides:
    
    toSequence in class BaseAnyMImpl<T>
    
    Returns:
    
    A Sequence that wraps a Stream
  - getMatchable
```
public T getMatchable()
```
    Specified by:
    
    getMatchable in interface Value<T>
    
    Returns:
    
    matchable
  - stream
```
public ReactiveSeq<T> stream()
```
    Specified by:
    
    stream in interface AnyM<T>
    
    Specified by:
    
    stream in interface AnyMValue<T>
    
    Specified by:
    
    stream in interface Foldable<T>
    
    Specified by:
    
    stream in interface ToStream<T>
    
    Specified by:
    
    stream in interface Value<T>
    
    Overrides:
    
    stream in class BaseAnyMImpl<T>
    
    Returns:
    
    SequenceM from this Streamable
  - map
```
public <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 AnyMValue<T>
    
    Specified by:
    
    map in interface ConvertableFunctor<T>
    
    Specified by:
    
    map in interface Functor<T>
  - bind
```
public <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>
    
    Specified by:
    
    bind in interface AnyMValue<T>
    
    Parameters:
    
    fn - flatMap function
    
    Returns:
    
    flatMapped monad
  - flatten
```
public <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 AnyMValue<T>
    
    Specified by:
    
    flatten in interface FlatMap<T>
    
    Returns:
    
    Flattened / joined one level
  - forEach2
```
public <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)
```
    Description copied from interface: AnyMValue
    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]
 
 
```
    Specified by:
    
    forEach2 in interface AnyMValue<T>
    
    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
```
public <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)
```
    Description copied from interface: AnyMValue
    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]
 
 
```
    Specified by:
    
    forEach2 in interface AnyMValue<T>
    
    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
```
public <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)
```
    Description copied from interface: AnyMValue
    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]
 
 
```
    Specified by:
    
    forEach3 in interface AnyMValue<T>
    
    Parameters:
    
    monad1 - Nested monad to flatMap over
    
    yieldingFunction - Function with pointers to the current element from both monads that generates the new elements
    
    Returns:
    
    AnyM with elements generated via nested iteration
  - forEach3
```
public <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)
```
    Description copied from interface: AnyMValue
    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]
 
 
```
    Specified by:
    
    forEach3 in interface AnyMValue<T>
    
    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
```
public <R> AnyMValue<R> flatMap(java.util.function.Function<? super T,? extends AnyMValue<? extends R>> fn)
```
    Description copied from interface: AnyMValue
    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]]
 
 
```
    Specified by:
    
    flatMap in interface AnyMValue<T>
    
    Parameters:
    
    fn - flatMap function
    
    Returns:
    
    flatMapped AnyM
  - unwrap
```
public <T> T unwrap()
```
    Specified by:
    
    unwrap in interface AnyM<T>
    
    Specified by:
    
    unwrap in interface Unwrapable
    
    Overrides:
    
    unwrap in class BaseAnyMImpl<T>
  - toString
```
public java.lang.String toString()
```
    Specified by:
    
    toString in interface AnyM<T>
    
    Overrides:
    
    toString in class BaseAnyMImpl<T>
    
    Returns:
    
    String representation of this AnyM
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - applyM
```
public <R> AnyMValue<R> applyM(AnyMValue<java.util.function.Function<? super T,? extends R>> fn)
```
    Description copied from interface: AnyMValue
    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)));
                        
```
    Specified by:
    
    applyM in interface AnyMValue<T>
    
    Returns:
  - toSequence
```
public <NT> ReactiveSeq<NT> toSequence()
```
    Description copied from class: BaseAnyMImpl
```
 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());
		
		
		
 
 
```
    Specified by:
    
    toSequence in interface AnyMValue<T>
    
    Overrides:
    
    toSequence in class BaseAnyMImpl<T>
    
    Returns:
    
    A Sequence that wraps a Stream

Class AnyMValueImpl<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.Applicativable

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

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

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

Field Summary

Fields inherited from class com.aol.cyclops.internal.monads.BaseAnyMImpl

Constructor Summary

Method Summary

Methods inherited from class com.aol.cyclops.internal.monads.BaseAnyMImpl

Methods inherited from class java.lang.Object

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

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.Applicativable

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.control.Matchable

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

Methods inherited from interface java.lang.Iterable

Methods inherited from interface java.util.function.Predicate

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

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

Constructor Detail

AnyMValueImpl

Method Detail

matchable

reactiveSeq

get

emptyUnit

replicateM

filter

peek

aggregate

unit

empty

toSequence

getMatchable

stream

map

bind

flatten

forEach2

forEach2

forEach3

forEach3

flatMap

unwrap

toString

hashCode

equals

applyM

toSequence