AnyMImpl (cyclops-streams 7.3.1 API)

java.lang.Object
- com.aol.cyclops.lambda.monads.AnyMImpl<T>

Type Parameters:

T -

All Implemented Interfaces:

AnyM<T>, ApplyM<T>, FlatMapM<T>, ReduceM<T>, ConvertableToSequenceM<T>, ToStream<T>, Unwrapable, java.lang.Iterable<T>
```
public class AnyMImpl<T>
extends java.lang.Object
implements AnyM<T>
```
Wrapper for Any Monad type

See Also:

companion class for static helper methods

Constructor Summary

Constructors
Constructor and Description

AnyMImpl()

Constructors
Constructor and Description
`AnyMImpl()`

Method Summary

All Methods Instance Methods Concrete 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<java.util.List<R>>`	`aggregateUntyped(AnyM<?> next)`
`<R> AnyM<R>`	`applyM(AnyM<java.util.function.Function<? super T,? extends R>> fn)` Apply function/s inside supplied Monad to data in current Monad e.g.
`<R> AnyM<R>`	`applyMCompletableFuture(java.util.concurrent.CompletableFuture<java.util.function.Function<? super T,? extends R>> fn)` Apply function/s inside supplied Monad to data in current Monad
`<R> AnyM<R>`	`applyMOptional(java.util.Optional<java.util.function.Function<? super T,? extends R>> fn)` Apply function/s inside supplied Monad to data in current Monad with Optionals
`<R> AnyM<R>`	`applyMStream(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)` Apply function/s inside supplied Monad to data in current Monad e.g.
`SequenceM<T>`	`asSequence()` Wrap this Monad's contents as a Sequence without disaggreating it.
`<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
`<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.
`AnyM<T>`	`filter(java.util.function.Predicate<? super T> fn)` Perform a filter operation on the wrapped monad instance e.g.
`<R> AnyM<R>`	`flatMap(java.util.function.Function<? super T,AnyM<? extends R>> fn)` flatMap operation
`AnyM<java.lang.String>`	`flatMapBufferedReader(java.util.function.Function<? super T,java.io.BufferedReader> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied BufferedReaders
`AnyM<java.lang.Character>`	`flatMapCharSequence(java.util.function.Function<? super T,java.lang.CharSequence> fn)` Perform a flatMap operation where the result will be a flattened stream of Characters from the CharSequence returned by the supplied function.
`<R> AnyM<R>`	`flatMapCollection(java.util.function.Function<? super T,java.util.Collection<? extends R>> fn)` flatMapping to a Stream will result in the Stream being converted to a List, if the host Monad type is not a Stream (or Stream like type).
`<R> AnyM<R>`	`flatMapCompletableFuture(java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)`
`AnyM<java.lang.String>`	`flatMapFile(java.util.function.Function<? super T,java.io.File> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied files.
`<R> AnyM<R>`	`flatMapOptional(java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)` Convenience method to allow method reference support, when flatMap return type is a Optional
`<R> AnyM<R>`	`flatMapSequenceM(java.util.function.Function<? super T,SequenceM<? extends R>> fn)` Convenience method to allow method reference support, when flatMap return type is a Stream.
`<R> AnyM<R>`	`flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)` Convenience method to allow method reference support, when flatMap return type is a Stream
`<R> AnyM<R>`	`flatMapStreamable(java.util.function.Function<? super T,Streamable<R>> fn)` Convenience method to allow method reference support, when flatMap return type is a Streamable
`AnyM<java.lang.String>`	`flatMapURL(java.util.function.Function<? super T,java.net.URL> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied URLs
`<T1> AnyM<T1>`	`flatten()` join / flatten one level of a nested hierarchy
`void`	`forEach(java.util.function.Consumer<? super T> action)`
`<R1,R> AnyM<R>`	`forEach2(java.util.function.Function<? super T,? extends AnyM<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> AnyM<R>`	`forEach2(java.util.function.Function<? super T,? extends AnyM<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> AnyM<R>`	`forEach3(java.util.function.Function<? super T,? extends AnyM<R1>> monad1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyM<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> AnyM<R>`	`forEach3(java.util.function.Function<? super T,? extends AnyM<R1>> monad1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyM<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
`java.util.Iterator<T>`	`iterator()`
`<R> AnyM<R>`	`liftAndBind(java.util.function.Function<? super T,?> fn)` Perform a bind operation (@see #bind) but also lift the return value into a Monad using configured MonadicConverters
`<R> AnyM<R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Perform a map operation on the wrapped monad instance e.g.
`Monad`	`monad()`
`AnyM<T>`	`peek(java.util.function.Consumer<? super T> c)` Perform a peek operation on the wrapped monad e.g.
`AnyM<T>`	`reduceM(Monoid<AnyM<T>> reducer)` Perform a reduction where NT is a (native) Monad type e.g.
`AnyM<T>`	`reduceMCompletableFuture(Monoid<java.util.concurrent.CompletableFuture<T>> reducer)` Perform a reduction where NT is a (native) Monad type e.g.
`AnyM<T>`	`reduceMIterable(Monoid<java.lang.Iterable<T>> reducer)` Perform a reduction where NT is a (native) Monad type e.g.
`AnyM<T>`	`reduceMOptional(Monoid<java.util.Optional<T>> reducer)` Perform a reduction where NT is a (native) Monad type e.g.
`AnyM<T>`	`reduceMStream(Monoid<java.util.stream.Stream<T>> reducer)` Perform a reduction where NT is a (native) Monad type e.g.
`AnyM<T>`	`reduceMStreamable(Monoid<Streamable<T>> reducer)` Perform a reduction where NT is a (native) Monad type e.g.
`AnyM<java.util.List<T>>`	`replicateM(int times)` Replicate given Monad
`SequenceM<T>`	`stream()`
`java.util.List<T>`	`toList()` Convert this monad into a List
`<T> SequenceM<T>`	`toSequence()` `Optional<List<Integer>> into Stream<Integer>`
`<NT> SequenceM<NT>`	`toSequence(java.util.function.Function<T,java.util.stream.Stream<NT>> fn)` Sequence the contents of a Monad.
`java.util.Set<T>`	`toSet()` Convert this monad into a Set
`java.lang.String`	`toString()`
`<T> AnyM<T>`	`unit(T value)` Construct a new instanceof AnyM using the type of the underlying wrapped monad
`<R> R`	`unwrap()`

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

Methods inherited from interface com.aol.cyclops.monad.AnyM
fromArray, fromCollection, fromCompletableFuture, fromDoubleStream, fromFile, fromIntStream, fromIterable, fromList, fromLongStream, fromOptional, fromOptionalDouble, fromOptionalInt, fromOptionalLong, fromRange, fromRangeLong, fromSet, fromStream, fromStreamable, fromURL, liftM, liftM2, liftM2, liftM3, liftM3, liftM4, liftM4, liftM5, liftM5, listFromCollection, listFromCompletableFuture, listFromIterable, listFromIterator, listFromOptional, listFromStream, listFromStreamable, ofConvertable, ofMonad, ofMonadList, ofNullable, sequence, sequence, streamOf, toCompletableFuture, toOptional, traverse, traverse

Methods inherited from interface com.aol.cyclops.sequence.streamable.ToStream
getStreamable, isEmpty, reveresedSequenceM, reveresedStream, sequenceM

Methods inherited from interface java.lang.Iterable
spliterator

Methods inherited from interface com.aol.cyclops.monad.ApplyM
applyMIterable

Constructor Detail
- AnyMImpl
```
public AnyMImpl()
```

Method Detail

unwrap
```
public final <R> R unwrap()
```
Specified by:

unwrap in interface AnyM<T>

Specified by:

unwrap in interface Unwrapable

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

Specified by:

collect in interface AnyM<T>

monad
```
public final Monad monad()
```
Specified by:

monad in interface AnyM<T>

filter

public final AnyM<T> filter(java.util.function.Predicate<? super T> fn)

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

map

public final <R> AnyM<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>
Returns:

peek
```
public final AnyM<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>

Parameters:

c - Consumer to accept current data

Returns:

AnyM after peek operation

bind
```
public final <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

Specified by:

bind in interface AnyM<T>

Parameters:

fn - flatMap function

Returns:

flatMapped monad

liftAndBind
```
public final <R> AnyM<R> liftAndBind(java.util.function.Function<? super T,?> fn)
```
Perform a bind operation (@see #bind) but also lift the return value into a Monad using configured MonadicConverters

Specified by:

liftAndBind in interface AnyM<T>

Parameters:

fn - flatMap function

Returns:

flatMapped monad

flatMapCharSequence

public final AnyM<java.lang.Character> flatMapCharSequence(java.util.function.Function<? super T,java.lang.CharSequence> fn)

Perform a flatMap operation where the result will be a flattened stream of Characters from the CharSequence returned by the supplied function.

 
 List<Character> result = anyM("input.file")
								.liftAndBindCharSequence(i->"hello world")
								.asSequence()
								.toList();
		
		assertThat(result,equalTo(Arrays.asList('h','e','l','l','o',' ','w','o','r','l','d')));

Specified by:: flatMapCharSequence in interface FlatMapM<T>
Parameters:: fn -
Returns:

flatMapFile

public final AnyM<java.lang.String> flatMapFile(java.util.function.Function<? super T,java.io.File> fn)

Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied files.

 
 		List<String> result = anyM("input.file")
								.map(getClass().getClassLoader()::getResource)
								.peek(System.out::println)
								.map(URL::getFile)
								.liftAndBindFile(File::new)
								.asSequence()
								.toList();
		
		assertThat(result,equalTo(Arrays.asList("hello","world")));

Specified by:: flatMapFile in interface FlatMapM<T>
Parameters:: fn -
Returns:

flatMapURL

public final AnyM<java.lang.String> flatMapURL(java.util.function.Function<? super T,java.net.URL> fn)

Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied URLs

  
 List<String> result = anyM("input.file")
								.liftAndBindURL(getClass().getClassLoader()::getResource)
								.asSequence()
								.toList();
		
		assertThat(result,equalTo(Arrays.asList("hello","world")));

Specified by:: flatMapURL in interface FlatMapM<T>
Parameters:: fn -
Returns:

flatMapBufferedReader

public final AnyM<java.lang.String> flatMapBufferedReader(java.util.function.Function<? super T,java.io.BufferedReader> fn)

Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied BufferedReaders

 
 List<String> result = anyM("input.file")
								.map(getClass().getClassLoader()::getResourceAsStream)
								.map(InputStreamReader::new)
								.liftAndBindBufferedReader(BufferedReader::new)
								.asSequence()
								.toList();
		
		assertThat(result,equalTo(Arrays.asList("hello","world")));

Specified by:: flatMapBufferedReader in interface FlatMapM<T>
Parameters:: fn -
Returns:

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

Specified by:

flatten in interface AnyM<T>

Returns:

Flattened / joined one level

aggregate

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

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>
Parameters:: next - Monad to aggregate content with
Returns:: Aggregated Monad

aggregateUntyped

public final <R> AnyM<java.util.List<R>> aggregateUntyped(AnyM<?> next)

forEach

public void forEach(java.util.function.Consumer<? super T> action)

Specified by:: forEach in interface java.lang.Iterable<T>

flatMap

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

flatMap operation

Specified by:: flatMap in interface AnyM<T>
Parameters:: fn -
Returns:

flatMapStream
```
public final <R> AnyM<R> flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)
```
Convenience method to allow method reference support, when flatMap return type is a Stream

Specified by:

flatMapStream in interface FlatMapM<T>

Parameters:

fn -

Returns:

flatMapStreamable
```
public final <R> AnyM<R> flatMapStreamable(java.util.function.Function<? super T,Streamable<R>> fn)
```
Convenience method to allow method reference support, when flatMap return type is a Streamable

Specified by:

flatMapStreamable in interface FlatMapM<T>

Parameters:

fn -

Returns:

flatMapCollection

public final <R> AnyM<R> flatMapCollection(java.util.function.Function<? super T,java.util.Collection<? extends R>> fn)

flatMapping to a Stream will result in the Stream being converted to a List, if the host Monad type is not a Stream (or Stream like type). (i.e.

    
   AnyM<Integer> opt = anyM(Optional.of(20));
   Optional<List<Integer>> optionalList = opt.flatMap( i -> anyM(Stream.of(1,2,i))).unwrap();  
   
   //Optional [1,2,20]

In such cases using Arrays.asList would be more performant

    
   AnyM<Integer> opt = anyM(Optional.of(20));
   Optional<List<Integer>> optionalList = opt.flatMapCollection( i -> asList(1,2,i))).unwrap();  
   
   //Optional [1,2,20]

Specified by:: flatMapCollection in interface FlatMapM<T>
Parameters:: fn -
Returns:

flatMapOptional
```
public final <R> AnyM<R> flatMapOptional(java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)
```
Convenience method to allow method reference support, when flatMap return type is a Optional

Specified by:

flatMapOptional in interface FlatMapM<T>

Parameters:

fn -

Returns:

flatMapCompletableFuture

public final <R> AnyM<R> flatMapCompletableFuture(java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)

Specified by:: flatMapCompletableFuture in interface FlatMapM<T>

flatMapSequenceM
```
public final <R> AnyM<R> flatMapSequenceM(java.util.function.Function<? super T,SequenceM<? extends R>> fn)
```
Description copied from interface: FlatMapM
Convenience method to allow method reference support, when flatMap return type is a Stream. 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->SequenceM.of(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->SequenceM.of(i+1,i+2));
   
   //AnyM[Optional[2]]
 
 
```
Specified by:

flatMapSequenceM in interface FlatMapM<T>

Parameters:

fn - flatMap function

Returns:

flatMapped AnyM

toSequence

public final <NT> SequenceM<NT> toSequence(java.util.function.Function<T,java.util.stream.Stream<NT>> fn)

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>
Returns:: A Sequence that wraps a Stream

toSequence

public final <T> SequenceM<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());

Specified by:: toSequence in interface AnyM<T>
Returns:: A Sequence that wraps a Stream

asSequence
```
public final SequenceM<T> asSequence()
```
Wrap this Monad's contents as a Sequence without disaggreating it. .e.
```
 Optional<List<Integer>>  into Stream<List<Integer>> 
```
If the underlying monad is a Stream it is returned Otherwise we flatMap the underlying monad to a Stream type
Specified by:

asSequence in interface AnyM<T>

applyM

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

Description copied from interface: AnyM

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 AnyM<T>
Returns:

unit
```
public <T> AnyM<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>

Parameters:

value - to embed inside the monad wrapped by AnyM

Returns:

Newly instantated AnyM

empty
```
public <T> AnyM<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>

Returns:

Empty AnyM

replicateM

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

Description copied from interface: AnyM

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 AnyM<T>
Parameters:: times - number of times to replicate
Returns:: Replicated Monad

reduceMOptional
```
public final AnyM<T> reduceMOptional(Monoid<java.util.Optional<T>> reducer)
```
Description copied from interface: ReduceM
Perform a reduction where NT is a (native) Monad type e.g.
```
 
   Monoid<Optional<Integer>> optionalAdd = Monoid.of(Optional.of(0), (a,b)-> Optional.of(a.get()+b.get()));
		
		AnyM.fromStream(Stream.of(2,8,3,1)).reduceM(optionalAdd);
		
		//AnyM[Optional(14)];
		
```
Specified by:

reduceMOptional in interface ReduceM<T>

Parameters:

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

Returns:

Reduced AnyM

reduceMStream

public final AnyM<T> reduceMStream(Monoid<java.util.stream.Stream<T>> reducer)

Description copied from interface: ReduceM

Perform a reduction where NT is a (native) Monad type e.g.

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

Specified by:: reduceMStream in interface ReduceM<T>
Parameters:: reducer - An identity value (approx. a seed) and BiFunction with a single type to reduce this anyM
Returns:: Reduced AnyM

reduceMStreamable
```
public final AnyM<T> reduceMStreamable(Monoid<Streamable<T>> reducer)
```
Description copied from interface: ReduceM
Perform a reduction where NT is a (native) Monad type e.g.
```
 
   Monoid<Optional<Integer>> streamableAdd = Monoid.of(Streamable.of(0), (a,b)-> Streamable.of(a.get()+b.get()));
		
		AnyM.fromStream(Stream.of(2,8,3,1)).reduceM(streamableAdd);
		
		//AnyM[Optional(14)];
		
```
Specified by:

reduceMStreamable in interface ReduceM<T>

Parameters:

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

Returns:

Reduced AnyM

reduceMIterable

public final AnyM<T> reduceMIterable(Monoid<java.lang.Iterable<T>> reducer)

Description copied from interface: ReduceM

Perform a reduction where NT is a (native) Monad type e.g.

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

Specified by:: reduceMIterable in interface ReduceM<T>
Parameters:: reducer - An identity value (approx. a seed) and BiFunction with a single type to reduce this anyM
Returns:: Reduced AnyM

reduceMCompletableFuture

public final AnyM<T> reduceMCompletableFuture(Monoid<java.util.concurrent.CompletableFuture<T>> reducer)

Description copied from interface: ReduceM

Perform a reduction where NT is a (native) Monad type e.g.

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

Specified by:: reduceMCompletableFuture in interface ReduceM<T>
Parameters:: reducer - An identity value (approx. a seed) and BiFunction with a single type to reduce this anyM
Returns:: Reduced AnyM

reduceM

public final AnyM<T> reduceM(Monoid<AnyM<T>> reducer)

Description copied from interface: AnyM

Perform a reduction where NT is a (native) Monad type e.g.

 
   Monoid<Optional<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)];

Specified by:: reduceM in interface AnyM<T>
Parameters:: reducer - An identity value (approx. a seed) and BiFunction with a single type to reduce this anyM
Returns:: Reduced AnyM

stream
```
public SequenceM<T> stream()
```
Specified by:

stream in interface AnyM<T>

Specified by:

stream in interface ToStream<T>

Returns:

New Stream

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

toString in interface AnyM<T>

Overrides:

toString in class java.lang.Object

Returns:

String representation of this AnyM

toList
```
public java.util.List<T> toList()
```
Description copied from interface: AnyM
Convert this monad into a List
Specified by:

toList in interface AnyM<T>

Returns:

AnyM as a List

toSet
```
public java.util.Set<T> toSet()
```
Description copied from interface: AnyM
Convert this monad into a Set
Specified by:

toSet in interface AnyM<T>

Returns:

AnyM as a Set

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

iterator in interface ToStream<T>

Specified by:

iterator in interface java.lang.Iterable<T>

applyMStream

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

Description copied from interface: ApplyM

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(Stream.of( (Integer a)->a+1 ,(Integer a) -> a*2));
	
	 	assertThat(applied.toList(),equalTo(Arrays.asList(2, 2, 3, 4, 4, 6)));

Specified by:: applyMStream in interface ApplyM<T>
Parameters:: fn - Stream of Functions to apply
Returns:: AnyM with functions applied

applyMOptional

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

Description copied from interface: ApplyM

Apply function/s inside supplied Monad to data in current Monad 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:: applyMOptional in interface ApplyM<T>
Returns:

applyMCompletableFuture

public <R> AnyM<R> applyMCompletableFuture(java.util.concurrent.CompletableFuture<java.util.function.Function<? super T,? extends R>> fn)

Description copied from interface: ApplyM

Apply function/s inside supplied Monad to data in current Monad


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

Specified by:: applyMCompletableFuture in interface ApplyM<T>
Returns:

forEach2
```
public <R1,R> AnyM<R> forEach2(java.util.function.Function<? super T,? extends AnyM<R1>> monad,
                               java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
```
Description copied from interface: AnyM
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 AnyM<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> AnyM<R> forEach2(java.util.function.Function<? super T,? extends AnyM<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: AnyM

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 AnyM<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> AnyM<R> forEach3(java.util.function.Function<? super T,? extends AnyM<R1>> monad1,
                                  java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyM<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: AnyM

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 AnyM<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

forEach3

public <R1,R2,R> AnyM<R> forEach3(java.util.function.Function<? super T,? extends AnyM<R1>> monad1,
                                  java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyM<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: AnyM

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 AnyM<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

Class AnyMImpl<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.aol.cyclops.sequence.streamable.ToStream

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.aol.cyclops.monad.ApplyM

Constructor Detail

AnyMImpl

Method Detail

unwrap

collect

monad

filter

map

peek

bind

liftAndBind

flatMapCharSequence

flatMapFile

flatMapURL

flatMapBufferedReader

flatten

aggregate

aggregateUntyped

forEach

flatMap

flatMapStream

flatMapStreamable

flatMapCollection

flatMapOptional

flatMapCompletableFuture

flatMapSequenceM

toSequence

toSequence

asSequence

applyM

unit

empty

replicateM

reduceMOptional

reduceMStream

reduceMStreamable

reduceMIterable

reduceMCompletableFuture

reduceM

stream

toString

toList

toSet

iterator

applyMStream

applyMOptional

applyMCompletableFuture

forEach2

forEach2

forEach3

forEach3