com.aol.cyclops.monad

Interface AnyM<T>

Type Parameters:

T -

All Superinterfaces:

Unwrapable

public interface AnyM<T>
extends Unwrapable

Wrapper for Any Monad type

See Also:

companion class for static helper methods

Method Summary

Modifier and Type	Method and Description
AnyM<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.
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
<T> AnyM<T>	empty()
AnyM<T>	filter(java.util.function.Predicate<? super T> fn)
<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)
<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
<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)
<X> X	monad()
AnyM<T>	peek(java.util.function.Consumer<? super T> c)
AnyM<T>	reduceM(Monoid<AnyM<T>> reducer)
AnyM<T>	reduceMCompletableFuture(Monoid<java.util.concurrent.CompletableFuture<T>> reducer)
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)
AnyM<T>	reduceMStreamable(Monoid<Streamable<T>> reducer)
AnyM<java.util.List<T>>	replicateM(int times) Replicate given Monad
AnyM<AnyM<T>>	simpleFilter(AnyM<java.util.function.Predicate<? super T>> fn) Filter current monad by each element in supplied Monad e.g.
AnyM<java.util.concurrent.CompletableFuture<T>>	simpleFilter(java.util.concurrent.CompletableFuture<java.util.function.Predicate<? super T>> fn)
AnyM<java.util.Optional<T>>	simpleFilter(java.util.Optional<java.util.function.Predicate<? super T>> fn)
AnyM<java.util.stream.Stream<T>>	simpleFilter(java.util.stream.Stream<java.util.function.Predicate<? super T>> fn)
AnyM<java.util.stream.Stream<T>>	simpleFilter(Streamable<java.util.function.Predicate<? super T>> fn)
default java.util.concurrent.CompletableFuture<java.util.List<T>>	toCompletableFuture()
default java.util.Optional<java.util.List<T>>	toOptional()
<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.lang.String	toString()
<T> AnyM<T>	unit(T value)
<R> R	unwrap()

Method Detail

unwrap

<R> R unwrap()

Specified by:

unwrap in interface Unwrapable

monad

<X> X monad()

filter

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

map

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

peek

AnyM<T> peek(java.util.function.Consumer<? super T> c)

bind

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

Perform a looser typed flatMap / bind operation The return type can be another type other than the host type

Parameters:

fn - flatMap function

Returns:

flatMapped monad

liftAndBind

<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

Parameters:

fn - flatMap function

Returns:

flatMapped monad

flatMapCharSequence

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

Parameters:

fn -

Returns:

flatMapFile

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

Parameters:

fn -

Returns:

flatMapURL

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

Parameters:

fn -

Returns:

flatMapBufferedReader

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

Parameters:

fn -

Returns:

flatten

<T1> AnyM<T1> flatten()

join / flatten one level of a nested hierarchy

Returns:

Flattened / joined one level

aggregate

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

Parameters:

next - Monad to aggregate content with

Returns:

Aggregated Monad

aggregateUntyped

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

flatMap

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

flatMap operation

Parameters:

fn -

Returns:

flatMapStream

<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

Parameters:

fn -

Returns:

flatMapStreamable

<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

Parameters:

fn -

Returns:

flatMapCollection

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

Parameters:

fn -

Returns:

flatMapOptional

<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

Parameters:

fn -

Returns:

flatMapCompletableFuture

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

flatMapSequenceM

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

toSequence

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

Returns:

A Sequence that wraps a Stream

toSequence

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

Returns:

A Sequence that wraps a Stream

asSequence

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

applyM

<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. with Streams

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

with Optionals

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

Parameters:

fn -

Returns:

simpleFilter

AnyM<AnyM<T>> simpleFilter(AnyM<java.util.function.Predicate<? super T>> fn)

Filter current monad by each element in supplied Monad e.g.

  AnyM<AnyM<Integer>> applied = anyM(Stream.of(1,2,3))
    									.filterM(anyM(Streamable.of( (Integer a)->a>5 ,(Integer a) -> a<3)))
    									.simplex();
 
  //results in AnyM((AnyM(1),AnyM(2),AnyM(())
 //or in terms of the underlying monad as Stream.of(Stream.of(1),Stream.of(2),Stream.of(())
 

Parameters:

fn -

Returns:

simpleFilter

AnyM<java.util.stream.Stream<T>> simpleFilter(java.util.stream.Stream<java.util.function.Predicate<? super T>> fn)

simpleFilter

AnyM<java.util.stream.Stream<T>> simpleFilter(Streamable<java.util.function.Predicate<? super T>> fn)

simpleFilter

AnyM<java.util.Optional<T>> simpleFilter(java.util.Optional<java.util.function.Predicate<? super T>> fn)

simpleFilter

AnyM<java.util.concurrent.CompletableFuture<T>> simpleFilter(java.util.concurrent.CompletableFuture<java.util.function.Predicate<? super T>> fn)

unit

<T> AnyM<T> unit(T value)

empty

<T> AnyM<T> empty()

replicateM

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

Replicate given Monad

 
 	
   AnyM<Optional<Integer>> applied =monad(Optional.of(2)).replicateM(5).simplex();
		 assertThat(applied.unwrap(),equalTo(Optional.of(Arrays.asList(2,2,2,2,2))));
		 
		 

Parameters:

times - number of times to replicate

Returns:

Replicated Monad

reduceMOptional

AnyM<T> reduceMOptional(Monoid<java.util.Optional<T>> reducer)

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()));
		
		assertThat(monad(Stream.of(2,8,3,1)).reduceM(optionalAdd).unwrap(),equalTo(Optional.of(14)));
		

Parameters:

reducer -

Returns:

reduceMStream

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

reduceMStreamable

AnyM<T> reduceMStreamable(Monoid<Streamable<T>> reducer)

reduceMCompletableFuture

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

reduceM

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

toString

java.lang.String toString()

Overrides:

toString in class java.lang.Object

toOptional

default java.util.Optional<java.util.List<T>> toOptional()

toCompletableFuture

default java.util.concurrent.CompletableFuture<java.util.List<T>> toCompletableFuture()