com.aol.cyclops.internal

Interface MonadFunctions<MONAD,T>

All Known Subinterfaces:

Monad<MONAD,T>

All Known Implementing Classes:

MonadWrapper

public interface MonadFunctions<MONAD,T>

Method Summary

Modifier and Type	Method and Description
default <NT,R> Monad<NT,R>	applyM(Monad<?,java.util.function.Function<? super T,? extends R>> fn) Apply function/s inside supplied Monad to data in current Monad e.g.
<R> Monad<MONAD,T>	bind(java.util.function.Function<? super T,? extends R> fn)
Monad<java.util.stream.Stream<T>,T>	cycle(int times)
default <NT,R> Monad<NT,R>	reduceM(Monoid<NT> reducer) Perform a reduction where NT is a (native) Monad type e.g.
default <NT,R> Monad<NT,R>	replicateM(int times) Replicate given Monad
default <NT,R> Monad<NT,R>	simpleFilter(Monad<?,java.util.function.Predicate<? super T>> fn) Filter current monad by each element in supplied Monad e.g.
java.util.stream.Stream<T>	stream()
<MONAD,T> MONAD	unit(T value)

Method Detail

bind

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

stream

java.util.stream.Stream<T> stream()

unit

<MONAD,T> MONAD unit(T value)

cycle

Monad<java.util.stream.Stream<T>,T> cycle(int times)

applyM

default <NT,R> Monad<NT,R> applyM(Monad<?,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 = AsAnyM.anyM(Stream.of(1,2,3))
                               .applyM(AsAnyM.anyM(Streamable.of( (Integer a)->a+1 ,(Integer a) -> a*2)));
	
	 	assertThat(applied.toSequence().toList(),equalTo(Arrays.asList(2, 2, 3, 4, 4, 6)));
	 

with Optionals

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

Parameters:

fn -

Returns:

simpleFilter

default <NT,R> Monad<NT,R> simpleFilter(Monad<?,java.util.function.Predicate<? super T>> fn)

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

  AnyM<Integer> applied = AsAnyM.anyM(Stream.of(1,2,3))
    									.filterM(AsAnyM.anyM(Streamable.of( (Integer a)->a>5 ,(Integer a) -> a<3)));
    									
 
 //results in Stream.of(Stream.of(1),Stream.of(2),Stream.of(())
 

Parameters:

fn -

Returns:

replicateM

default <NT,R> Monad<NT,R> replicateM(int times)

Replicate given Monad

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

Parameters:

times - number of times to replicate

Returns:

Replicated Monad

reduceM

default <NT,R> Monad<NT,R> reduceM(Monoid<NT> 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(AsAnyM.anyM(Stream.of(2,8,3,1)).reduceM(optionalAdd).unwrap(),equalTo(Optional.of(14)));
		

Parameters:

reducer -

Returns: