Monad (simple-react 1.0.0-RC4 API)

Type Parameters:

T -

MONAD -

All Superinterfaces:

Filterable<T>, Functor<T>, WrappingFilterable<T>, WrappingFunctor<T>

All Known Implementing Classes:

MonadWrapper
```
public interface Monad<T>
extends WrappingFunctor<T>, WrappingFilterable<T>
```
An interoperability Trait that encapsulates java Monad implementations. A generalised view into Any Monad (that implements flatMap or bind and accepts any function definition with an arity of 1). Operates as a Monad Monad (yes two Monads in a row! - or a Monad that encapsulates and operates on Monads). NB the intended use case is to wrap already existant Monad-like objects from diverse sources, to improve interoperability - it's not intended for use as an interface to be implemented on a Monad class.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`<T> AnyMSeq<T>`	`anyMSeq()`
`<T> AnyMValue<T>`	`anyMValue()`
`default <R> Monad<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.
`default <R> Monad<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
`default Monad<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`default Monad<T>`	`empty()`
`default Monad<T>`	`filter(java.util.function.Predicate<? super T> fn)` Keep only elements for which the supplied predicates hold e.g.
`default <R> Monad<R>`	`flatMapToStream(java.util.function.Function<java.lang.Object,? extends java.util.stream.Stream<? extends R>> fn)`
`default <T1> Monad<T1>`	`flatten()` join / flatten one level of a nested hierarchy
`static <T> Monad<T>`	`fromStream(java.util.stream.Stream<T> monad)`
`default T`	`get()`
`default java.lang.Object`	`getFilterable()`
`default java.lang.Object`	`getFunctor()` Override this method if you are using this class to wrap a Functor that does not implement this interface natively.
`default <R> Monad<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
`default <R> Monad<R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`static <T> Monad<T>`	`of(java.lang.Object o)`
`default Monad<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Functor, without transforming it
`default <R> Monad<R>`	`reduceM(Monoid<R> reducer)` Perform a reduction where NT is a (native) Monad type e.g.
`default <R> Monad<R>`	`replicateM(int times)` Replicate given Monad
`<T> ReactiveSeq<T>`	`sequence()`
`default java.util.stream.Stream<T>`	`stream()` Unwrap this Monad into a Stream.
`default <NT> Monad<NT>`	`streamedMonad()` Transform the contents of a Monad into a Monad wrapping a Stream e.g.
`default <T> java.lang.Object`	`unit(T value)` Generate a new instance of the underlying monad with given value
`java.lang.Object`	`unwrap()`
`default WrappingFilterable<T>`	`withFilterable(T filter)`
`default <T> Monad<T>`	`withFunctor(T functor)` Will attempt to create a new instance of this functor type via constructor reflection if this is a wrapped Functor (i.e.
`<T> Monad<T>`	`withMonad(java.lang.Object invoke)`

Methods inherited from interface com.aol.cyclops.types.Functor
cast, patternMatch, trampoline

Methods inherited from interface com.aol.cyclops.types.Filterable
filterNot, notNull, ofType

Method Detail

withMonad

<T> Monad<T> withMonad(java.lang.Object invoke)

withFunctor
```
default <T> Monad<T> withFunctor(T functor)
```
Description copied from interface: WrappingFunctor

Will attempt to create a new instance of this functor type via constructor reflection if this is a wrapped Functor (i.e. getFunctor returns another instance) otherwise returns the supplied functor

Specified by:

withFunctor in interface WrappingFunctor<T>

Returns:

getFunctor
```
default java.lang.Object getFunctor()
```
Description copied from interface: WrappingFunctor

Override this method if you are using this class to wrap a Functor that does not implement this interface natively.

Specified by:

getFunctor in interface WrappingFunctor<T>

Returns:

underlying functor

streamedMonad

default <NT> Monad<NT> streamedMonad()

Transform the contents of a Monad into a Monad wrapping a Stream e.g. Turn an

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


 List<List<Integer>> list = monad(Optional.of(Arrays.asList(1,2,3,4,5,6)))
											.<Stream<Integer>,Integer>streamedMonad()
											.grouped(3)
											.collect(Collectors.toList());
		
		
		assertThat(list.get(0),hasItems(1,2,3));
		assertThat(list.get(1),hasItems(4,5,6));

Returns:: A Monad that wraps a Stream

stream
```
default java.util.stream.Stream<T> stream()
```
Unwrap this Monad into a Stream. If the underlying monad is a Stream it is returned Otherwise we flatMap the underlying monad to a Stream type

cycle
```
default Monad<T> cycle(int times)
```
Convert to a Stream with the values repeated specified times

Parameters:

times - Times values should be repeated within a Stream

Returns:

Stream with values repeated

withFilterable
```
default WrappingFilterable<T> withFilterable(T filter)
```
Specified by:

withFilterable in interface WrappingFilterable<T>

getFilterable
```
default java.lang.Object getFilterable()
```
Specified by:

getFilterable in interface WrappingFilterable<T>

filter
```
default Monad<T> filter(java.util.function.Predicate<? super T> fn)
```
Description copied from interface: Filterable
Keep only elements for which the supplied predicates hold e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[3]
   
 
 
```
Specified by:

filter in interface Filterable<T>

Specified by:

filter in interface WrappingFilterable<T>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filterable with elements removed where the predicate does not hold

map
```
default <R> Monad<R> map(java.util.function.Function<? super T,? extends R> fn)
```
Description copied from interface: Functor
Transform this functor using the supplied transformation function
```
  
  
  
    of(1,2,3).map(i->i*2)
    
    //[2,4,6]
  
 
 
```
Specified by:

map in interface Functor<T>

Specified by:

map in interface WrappingFunctor<T>

Parameters:

fn - Transformation function

Returns:

Transformed Functor

peek
```
default Monad<T> peek(java.util.function.Consumer<? super T> c)
```
Description copied from interface: Functor
Peek at the current value of this Functor, without transforming it
```
  
  
  
    of(1,2,3).map(System.out::println)
    
    1
    2
    3
  
 
 
```
Specified by:

peek in interface Functor<T>

Specified by:

peek in interface WrappingFunctor<T>

Parameters:

c - Consumer that recieves each element from this Functor

Returns:

Functor that will peek at each value

bind
```
default <R> Monad<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
```
default <R> Monad<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

flatten
```
default <T1> Monad<T1> flatten()
```
join / flatten one level of a nested hierarchy

Returns:

Flattened / joined one level

flatMapToStream

default <R> Monad<R> flatMapToStream(java.util.function.Function<java.lang.Object,? extends java.util.stream.Stream<? extends R>> fn)

unit
```
default <T> java.lang.Object unit(T value)
```
Generate a new instance of the underlying monad with given value

Parameters:

value - to construct new instance with

Returns:

new instance of underlying Monad

get
```
default T get()
```

unwrap
```
java.lang.Object unwrap()
```
Specified by:

unwrap in interface WrappingFunctor<T>

anyMValue
```
<T> AnyMValue<T> anyMValue()
```

anyMSeq
```
<T> AnyMSeq<T> anyMSeq()
```

sequence
```
<T> ReactiveSeq<T> sequence()
```

of

static <T> Monad<T> of(java.lang.Object o)

empty
```
default Monad<T> empty()
```

fromStream

static <T> Monad<T> fromStream(java.util.stream.Stream<T> monad)

applyM

default <R> Monad<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:

replicateM

default <R> Monad<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 <R> Monad<R> reduceM(Monoid<R> 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:

Interface Monad<T>

Method Summary

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

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

Method Detail

withMonad

withFunctor

getFunctor

streamedMonad

stream

cycle

withFilterable

getFilterable

filter

map

peek

bind

liftAndBind

flatten

flatMapToStream

unit

get

unwrap

anyMValue

anyMSeq

sequence

of

empty

fromStream

applyM

replicateM

reduceM