Monad (cyclops-streams 7.3.1 API)

Type Parameters:

T -

MONAD -

All Superinterfaces:

Filterable<T>, Functor<T>, MonadFunctions<MONAD,T>, WrappingFunctor<T>

All Known Implementing Classes:

MonadWrapper
```
public interface Monad<MONAD,T>
extends MonadFunctions<MONAD,T>, WrappingFunctor<T>, Filterable<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
`default <R> Monad<MONAD,R>`	`aggregate(Monad<?,?> next)` Aggregate the contents of this Monad and the supplied Monad
`<T> AnyM<T>`	`anyM()`
`default <R> Monad<MONAD,T>`	`bind(java.util.function.Function<? super T,? extends R> fn)` Perform a looser typed flatMap / bind operation The return type can be another type other than the host type
`default Monad<java.util.stream.Stream<T>,T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`default Monad<MONAD,T>`	`filter(java.util.function.Predicate<? super T> fn)`
`default <R extends MONAD,NT> Monad<R,NT>`	`flatMap(java.util.function.Function<? super T,? extends R> fn)` flatMap operation
`default <R> Monad<java.util.concurrent.CompletableFuture<R>,R>`	`flatMapToCompletableFuture(java.util.function.Function<? super MONAD,java.util.concurrent.CompletableFuture<? extends R>> fn)`
`default <R> Monad<java.util.Optional<R>,R>`	`flatMapToOptional(java.util.function.Function<? super MONAD,java.util.Optional<? extends R>> fn)`
`default <R> Monad<java.util.stream.Stream<R>,R>`	`flatMapToStream(java.util.function.Function<? super MONAD,java.util.stream.Stream<? extends R>> fn)`
`default <T1> Monad<T,T1>`	`flatten()` join / flatten one level of a nested hierarchy
`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 <MONAD1,R> Monad<MONAD1,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<MONAD,R>`	`map(java.util.function.Function<? super T,? extends R> fn)`
`default java.util.Optional<MONAD>`	`monadFilter(java.util.function.Predicate<? super MONAD> p)`
`default <MONAD2,NT,R extends Monad<MONAD2,NT>> R`	`monadFlatMap(java.util.function.Function<? super MONAD,? extends R> fn)`
`default <MONAD2,NT> Monad<MONAD2,NT>`	`monadMap(java.util.function.Function<? super MONAD,? extends NT> fn)`
`static <MONAD,T> Monad<MONAD,T>`	`of(java.lang.Object o)` Create a duck typed Monad wrapper.
`default Monad<MONAD,T>`	`peek(java.util.function.Consumer<? super T> c)`
`<T> SequenceM<T>`	`sequence()`
`default java.util.stream.Stream<T>`	`stream()` Unwrap this Monad into a Stream.
`default <R,NT> Monad<R,NT>`	`streamedMonad()` Transform the contents of a Monad into a Monad wrapping a Stream e.g.
`default <T> java.util.Optional<T>`	`toOptional()`
`default <MONAD,T> MONAD`	`unit(T value)` Generate a new instance of the underlying monad with given value
`default MONAD`	`unwrap()`
`default Filterable<T>`	`withFilterable(T filter)`
`default <T> Monad<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.
`<MONAD,T> Monad<MONAD,T>`	`withMonad(java.lang.Object invoke)`

Methods inherited from interface com.aol.cyclops.internal.MonadFunctions
applyM, reduceM, replicateM, simpleFilter

- Method Detail
  - withMonad
```
<MONAD,T> Monad<MONAD,T> withMonad(java.lang.Object invoke)
```
  - withFunctor
```
default <T> Monad<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 <R,NT> Monad<R,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
    
    Specified by:
    
    stream in interface MonadFunctions<MONAD,T>
  - cycle
```
default Monad<java.util.stream.Stream<T>,T> cycle(int times)
```
    Convert to a Stream with the values repeated specified times
    
    Specified by:
    
    cycle in interface MonadFunctions<MONAD,T>
    
    Parameters:
    
    times - Times values should be repeated within a Stream
    
    Returns:
    
    Stream with values repeated
  - withFilterable
```
default Filterable<T> withFilterable(T filter)
```
    Specified by:
    
    withFilterable in interface Filterable<T>
  - getFilterable
```
default java.lang.Object getFilterable()
```
    Specified by:
    
    getFilterable in interface Filterable<T>
  - filter
```
default Monad<MONAD,T> filter(java.util.function.Predicate<? super T> fn)
```
    Specified by:
    
    filter in interface Filterable<T>
  - map
```
default <R> Monad<MONAD,R> map(java.util.function.Function<? super T,? extends R> fn)
```
    Specified by:
    
    map in interface Functor<T>
    
    Specified by:
    
    map in interface WrappingFunctor<T>
  - peek
```
default Monad<MONAD,T> peek(java.util.function.Consumer<? super T> c)
```
    Specified by:
    
    peek in interface Functor<T>
    
    Specified by:
    
    peek in interface WrappingFunctor<T>
  - bind
```
default <R> Monad<MONAD,T> bind(java.util.function.Function<? super T,? extends R> 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 MonadFunctions<MONAD,T>
    
    Parameters:
    
    fn - flatMap function
    
    Returns:
    
    flatMapped monad
  - liftAndBind
```
default <MONAD1,R> Monad<MONAD1,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<T,T1> flatten()
```
    join / flatten one level of a nested hierarchy
    
    Returns:
    
    Flattened / joined one level
  - toOptional
```
default <T> java.util.Optional<T> toOptional()
```
    Returns:
    This monad coverted to an Optional Streams will be converted into
    Optional<List<T>>
  - flatMapToOptional
```
default <R> Monad<java.util.Optional<R>,R> flatMapToOptional(java.util.function.Function<? super MONAD,java.util.Optional<? extends R>> fn)
```
  - flatMapToStream
```
default <R> Monad<java.util.stream.Stream<R>,R> flatMapToStream(java.util.function.Function<? super MONAD,java.util.stream.Stream<? extends R>> fn)
```
  - flatMapToCompletableFuture
```
default <R> Monad<java.util.concurrent.CompletableFuture<R>,R> flatMapToCompletableFuture(java.util.function.Function<? super MONAD,java.util.concurrent.CompletableFuture<? extends R>> fn)
```
  - unit
```
default <MONAD,T> MONAD unit(T value)
```
    Generate a new instance of the underlying monad with given value
    
    Specified by:
    
    unit in interface MonadFunctions<MONAD,T>
    
    Parameters:
    
    value - to construct new instance with
    
    Returns:
    
    new instance of underlying Monad
  - aggregate
```
default <R> Monad<MONAD,R> aggregate(Monad<?,?> next)
```
    Aggregate the contents of this Monad and the supplied Monad
```
 
 
 List<Integer> result = monad(Stream.of(1,2,3,4)).<Integer>aggregate(monad(Optional.of(5))).toList();
		
		assertThat(result,equalTo(Arrays.asList(1,2,3,4,5)));
		
```
    Parameters:
    
    next - Monad to aggregate content with
    
    Returns:
    
    Aggregated Monad
  - monadMap
```
default <MONAD2,NT> Monad<MONAD2,NT> monadMap(java.util.function.Function<? super MONAD,? extends NT> fn)
```
  - monadFilter
```
default java.util.Optional<MONAD> monadFilter(java.util.function.Predicate<? super MONAD> p)
```
  - monadFlatMap
```
default <MONAD2,NT,R extends Monad<MONAD2,NT>> R monadFlatMap(java.util.function.Function<? super MONAD,? extends R> fn)
```
  - flatMap
```
default <R extends MONAD,NT> Monad<R,NT> flatMap(java.util.function.Function<? super T,? extends R> fn)
```
    flatMap operation
    
    Parameters:
    
    fn -
    
    Returns:
  - unwrap
```
default MONAD unwrap()
```
    Specified by:
    
    unwrap in interface WrappingFunctor<T>
  - anyM
```
<T> AnyM<T> anyM()
```
    Returns:
    AnyM view on a wrapped Monad, with a single typed parameter - which is the datatype ultimately being handled by the Monad. E.g.
    Monad<Stream<String>,String> becomes Simplex<String>
    To get back to
    Stream<String>
    use
    simplex.<Stream<String>>.monad();
  - sequence
```
<T> SequenceM<T> sequence()
```
  - of
```
static <MONAD,T> Monad<MONAD,T> of(java.lang.Object o)
```
    Create a duck typed Monad wrapper. Using AnyM we focus only on the underlying type e.g. instead of
```
  
  Monad<Stream<Integer>,Integer> stream;
 
 we can write
 
   AnyM<Integer> stream;
 
```
    The wrapped Monaad should have equivalent methods for
```
  
 map(F f)
 
 flatMap(F<x,MONAD> fm)
 
 and optionally 
 
 filter(P p)
 
 
```
    A Comprehender instance can be created and registered for new Monad Types. Cyclops will attempt to manage any Monad type (via the InvokeDynamicComprehender) althouh behaviour is best guaranteed with customised Comprehenders. Where F is a Functional Interface of any type that takes a single parameter and returns a result. Where P is a Functional Interface of any type that takes a single parameter and returns a boolean flatMap operations on the duck typed Monad can return any Monad type
    Parameters:
    
    o - to wrap
    
    Returns:
    
    Duck typed Monad

Interface Monad<MONAD,T>

Method Summary

Methods inherited from interface com.aol.cyclops.internal.MonadFunctions

Method Detail

withMonad

withFunctor

getFunctor

streamedMonad

stream

cycle

withFilterable

getFilterable

filter

map

peek

bind

liftAndBind

flatten

toOptional

flatMapToOptional

flatMapToStream

flatMapToCompletableFuture

unit

aggregate

monadMap

monadFilter

monadFlatMap

flatMap

unwrap

anyM

sequence

of