T
- MONAD
- public interface Monad<MONAD,T> extends MonadFunctions<MONAD,T>, WrappingFunctor<T>, WrappingFilterable<T>
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() |
<T> AnyMSeq<T> |
anyMSeq() |
<T> AnyMValue<T> |
anyMValue() |
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> |
empty() |
default Monad<MONAD,T> |
filter(java.util.function.Predicate<? super T> fn) |
default <R extends MONAD,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
|
static <T> Monad<java.util.stream.Stream<T>,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 <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>> |
monadFlatMap(java.util.function.Function<? super MONAD,? extends R> fn) |
default <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> ReactiveSeq<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 WrappingFilterable<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) |
applyM, reduceM, replicateM
cast, patternMatch, trampoline
filterNot, notNull, ofType
<MONAD,T> Monad<MONAD,T> withMonad(java.lang.Object invoke)
default <T> Monad<MONAD,T> withFunctor(T functor)
WrappingFunctor
withFunctor
in interface WrappingFunctor<T>
default java.lang.Object getFunctor()
WrappingFunctor
getFunctor
in interface WrappingFunctor<T>
default <R,NT> Monad<R,NT> streamedMonad()
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));
default java.util.stream.Stream<T> stream()
stream
in interface MonadFunctions<MONAD,T>
default Monad<java.util.stream.Stream<T>,T> cycle(int times)
cycle
in interface MonadFunctions<MONAD,T>
times
- Times values should be repeated within a Streamdefault WrappingFilterable<T> withFilterable(T filter)
withFilterable
in interface WrappingFilterable<T>
default java.lang.Object getFilterable()
getFilterable
in interface WrappingFilterable<T>
default Monad<MONAD,T> filter(java.util.function.Predicate<? super T> fn)
filter
in interface Filterable<T>
filter
in interface WrappingFilterable<T>
default <R> Monad<MONAD,T> bind(java.util.function.Function<? super T,? extends R> fn)
bind
in interface MonadFunctions<MONAD,T>
fn
- flatMap functiondefault <MONAD1,R> Monad<MONAD1,R> liftAndBind(java.util.function.Function<? super T,?> fn)
fn
- flatMap functiondefault <T1> Monad<T,T1> flatten()
default <T> java.util.Optional<T> toOptional()
Optional<List<T>>
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 <R> Monad<java.util.concurrent.CompletableFuture<R>,R> flatMapToCompletableFuture(java.util.function.Function<? super MONAD,java.util.concurrent.CompletableFuture<? extends R>> fn)
default <MONAD,T> MONAD unit(T value)
unit
in interface MonadFunctions<MONAD,T>
value
- to construct new instance withdefault T get()
default <R> Monad<MONAD,R> aggregate(Monad<?,?> next)
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)));
next
- Monad to aggregate content withdefault <MONAD2,NT> Monad<MONAD2,NT> monadMap(java.util.function.Function<? super MONAD,? extends NT> 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 <R extends MONAD,NT> Monad<R,NT> flatMap(java.util.function.Function<? super T,? extends R> fn)
fn
- default MONAD unwrap()
unwrap
in interface WrappingFunctor<T>
<T> AnyM<T> anyM()
Monad<Stream<String>,String> becomes Simplex<String>
To get back to Stream<String>
use
simplex.<Stream<String>>.monad();
<T> AnyMValue<T> anyMValue()
<T> AnyMSeq<T> anyMSeq()
<T> ReactiveSeq<T> sequence()
static <MONAD,T> Monad<MONAD,T> of(java.lang.Object o)
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 typeo
- to wrapstatic <T> Monad<java.util.stream.Stream<T>,T> fromStream(java.util.stream.Stream<T> monad)