com.aol.cyclops.lambda.monads

Interface Monad<MONAD,T>

Type Parameters:

T -

MONAD -

All Superinterfaces:

AsGenericMonad, Filterable<T>, Functor<T>, java.lang.Iterable<T>, Streamable<T>

All Known Subinterfaces:

Simplex<X>

All Known Implementing Classes:

MonadWrapper, SimplexImpl

public interface Monad<MONAD,T>
extends Functor<T>, Filterable<T>, Streamable<T>, AsGenericMonad

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

Method Summary

Modifier and Type	Method and Description
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)));
default void	allMatch(java.util.function.Predicate<T> c) True if predicate matches all elements when Monad converted to a Stream
default void	anyMatch(java.util.function.Predicate<T> c) True if a single element matches when Monad converted to a Stream
default <NT,R> Monad<NT,R>	applyM(Monad<?,java.util.function.Function<T,R>> fn) Apply function/s inside supplied Monad to data in current Monad e.g.
default <R> Monad<MONAD,T>	bind(java.util.function.Function<T,R> fn) Perform a looser typed flatMap / bind operation The return type can be another type other than the host type
default <R,A> R	collect(java.util.stream.Collector<T,A,R> collector) Mutable reduction / collection over this Monad converted to a Stream
default java.util.List	collect(java.util.stream.Stream<java.util.stream.Collector> collectors) Apply multiple collectors Simulataneously to this Monad List result = monad(Stream.of(1,2,3)).collect(Stream.of(Collectors.toList(), Collectors.summingInt(Integer::intValue), Collectors.averagingInt(Integer::intValue))); assertThat(result.get(0),equalTo(Arrays.asList(1,2,3))); assertThat(result.get(1),equalTo(6)); assertThat(result.get(2),equalTo(2.0)); NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
default <R> Monad<java.util.stream.Stream<R>,R>	cycle(java.lang.Class<R> monad, int times) Convert to a Stream, repeating the resulting structure specified times and lifting all values to the specified Monad type List<Optional<Integer>> list = monad(Stream.of(1,2)) .cycle(Optional.class,2) .toList(); //is asList(Optional.of(1),Optional.of(2),Optional.of(1),Optional.of(2) ));
default Monad<java.util.stream.Stream<T>,T>	cycle(int times) Convert to a Stream with the values repeated specified times
default Monad<java.util.stream.Stream<T>,T>	cycle(Monoid<T> m, int times) Convert to a Stream with the result of a reduction operation repeated specified times List<Integer> list = AsGenericMonad,asMonad(Stream.of(1,2,2)) .cycle(Reducers.toCountInt(),3) .collect(Collectors.toList()); //is asList(3,3,3);
default Monad<java.util.stream.Stream<T>,T>	cycleUntil(java.util.function.Predicate<T> predicate) Repeat in a Stream until specified predicate holds
default Monad<java.util.stream.Stream<T>,T>	cycleWhile(java.util.function.Predicate<T> predicate) Repeat in a Stream while specified predicate holds
default Monad<java.util.stream.Stream<T>,T>	distinct()
default Monad<MONAD,T>	filter(java.util.function.Predicate<T> fn)
default <NT,R> Monad<NT,R>	filterM(Monad<?,java.util.function.Predicate<T>> fn) Filter current monad by each element in supplied Monad e.g.
default java.util.Optional<T>	findAny()
default java.util.Optional<T>	findFirst()
default <R extends MONAD,NT> Monad<R,NT>	flatMap(java.util.function.Function<T,R> fn) flatMap operation
default <R> Monad<java.util.concurrent.CompletableFuture<R>,R>	flatMapToCompletableFuture(java.util.function.Function<MONAD,java.util.concurrent.CompletableFuture<R>> fn)
default <R> Monad<java.util.Optional<R>,R>	flatMapToOptional(java.util.function.Function<MONAD,java.util.Optional<R>> fn)
default <R> Monad<java.util.stream.Stream<R>,R>	flatMapToStream(java.util.function.Function<MONAD,java.util.stream.Stream<R>> fn)
default <T1> Monad<T,T1>	flatten() join / flatten one level of a nested hierarchy
default T	foldLeft(Monoid<T> reducer)
default <T> T	foldLeftMapToType(Monoid<T> reducer) Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
default T	foldRight(Monoid<T> reducer)
default <T> T	foldRightMapToType(Monoid<T> reducer) Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
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.
java.lang.Object	getMonad()
default Monad<java.util.stream.Stream<java.util.List<T>>,java.util.List<T>>	grouped(int groupSize) Group elements in a Monad into a Stream List<List<Integer>> list = monad(Stream.of(1,2,3,4,5,6)) .grouped(3) .collect(Collectors.toList()); assertThat(list.get(0),hasItems(1,2,3)); assertThat(list.get(1),hasItems(4,5,6));
default <MONAD1,R> Monad<MONAD1,R>	liftAndBind(java.util.function.Function<T,?> fn) Perform a bind operation (@see #bind) but also lift the return value into a Monad using configured MonadicConverters
default Monad<java.util.stream.Stream<T>,T>	limit(int num) NB to access nested collections in non-Stream monads as a stream use streamedMonad() first assertThat(monad(Stream.of(4,3,6,7)).limit(2).toList(),equalTo(Arrays.asList(4,3)));
default Monad<java.util.stream.Stream<T>,T>	limitUntil(java.util.function.Predicate<T> p) NB to access nested collections in non-Stream monads as a stream use streamedMonad() first assertThat(monad(Stream.of(4,3,6,7)).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3)));
default Monad<java.util.stream.Stream<T>,T>	limitWhile(java.util.function.Predicate<T> p) NB to access nested collections in non-Stream monads as a stream use streamedMonad() first assertThat(monad(Stream.of(4,3,6,7)).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
default <R> Monad<MONAD,R>	map(java.util.function.Function<T,R> fn)
default <R> R	mapReduce(java.util.function.Function<T,R> mapper, Monoid<R> reducer) Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values
default <R> R	mapReduce(Monoid<R> reducer) Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
default <R,NT> Monad<R,NT>	parallel()
default Monad<MONAD,T>	peek(java.util.function.Consumer<T> c)
default java.util.List<T>	reduce(java.lang.Iterable<Monoid<T>> reducers) Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
default T	reduce(Monoid<T> reducer) NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
default java.util.List<T>	reduce(java.util.stream.Stream<Monoid<T>> reducers) Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
default <NT,R> Monad<NT,R>	replicateM(int times) Replicate given Monad Simplex<Optional<Integer>> applied =monad(Optional.of(2)).replicateM(5).simplex(); assertThat(applied.unwrap(),equalTo(Optional.of(Arrays.asList(2,2,2,2,2))));
default Monad<java.util.stream.Stream<T>,T>	scanLeft(Monoid<T> monoid) Scan left using supplied Monoid assertEquals(asList("", "a", "ab", "abc"),monad(Stream.of("a", "b", "c")).scanLeft(Reducers.toString("")).toList());
static <MONAD,T> Monad<MONAD,T>	sequence(java.lang.Class c, java.util.List<?> seq) Convert a list of Monads to a Monad with a List List<CompletableFuture<Integer>> futures; Simplex<List<Integer>> futureList = Monad.sequence(CompletableFuture.class, futures).simplex();
static <MONAD,MONAD_LIST> MONAD_LIST	sequenceNative(java.lang.Class c, java.util.List<MONAD> seq) Convert a list of Monads to a Monad with a List List<CompletableFuture<Integer>> futures; CompletableFuture<List<Integer>> futureList = Monad.sequence(CompletableFuture.class, futures);
default <X> Simplex<X>	simplex()
default Monad<java.util.stream.Stream<T>,T>	skip(int num) assertThat(monad(Stream.of(4,3,6,7)).skip(2).toList(),equalTo(Arrays.asList(6,7))); NB to access nested collections in non-Stream monads as a stream use streamedMonad() first
default Monad<java.util.stream.Stream<T>,T>	skipUntil(java.util.function.Predicate<T> p) NB to access nested collections in non-Stream monads as a stream use streamedMonad() first assertThat(monad(Stream.of(4,3,6,7)).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
default Monad<java.util.stream.Stream<T>,T>	skipWhile(java.util.function.Predicate<T> p) NB to access nested collections in non-Stream monads as a stream use streamedMonad() first assertThat(monad(Stream.of(4,3,6,7)).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
default Monad<java.util.stream.Stream<java.util.List<T>>,java.util.List<T>>	sliding(int windowSize) Create a sliding view over this monad
default Monad<java.util.stream.Stream<T>,T>	sorted()
default Monad<java.util.stream.Stream<T>,T>	sorted(java.util.Comparator<T> c) Monad converted to Stream via stream() and sorted - to access nested collections in non-Stream monads as a stream use streamedMonad() first e.g.
default boolean	startsWith(java.lang.Iterable<T> iterable) assertTrue(monad(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3)));
default boolean	startsWith(java.util.Iterator<T> iterator) assertTrue(monad(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3).iterator()))
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 java.util.List<T>	toList()
default <T> java.util.Optional<T>	toOptional()
default java.util.Set<T>	toSet()
default <T> java.util.stream.Stream<T>	toStream()
default Streamable<T>	toStreamable()
static <MONAD,R> Monad<MONAD,java.util.List<R>>	traverse(java.lang.Class c, java.util.List<?> seq, java.util.function.Function<?,R> fn) Convert a list of Monads to a Monad with a List applying the supplied function in the process List<CompletableFuture<Integer>> futures; Simplex<List<String>> futureList = Monad.traverse(CompletableFuture.class, futures, (Integer i) -> "hello" +i).simplex();
static <MONAD,MONAD_LIST,R> MONAD_LIST	traverseNative(java.lang.Class c, java.util.List<MONAD> seq, java.util.function.Function<?,R> fn) Convert a list of Monads to a Monad with a List applying the supplied function in the process List<CompletableFuture<Integer>> futures; CompletableFuture<List<String>> futureList = Monad.traverse(CompletableFuture.class, futures, (Integer i) -> "hello" +i);
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)
default <MONAD2,S,R> Monad<java.util.stream.Stream<R>,R>	zip(Monad<MONAD2,? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper) Generic zip function.
default <S,R> Monad<java.util.stream.Stream<R>,R>	zip(java.util.stream.Stream<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper) Zip this Monad with a Stream Stream<List<Integer>> zipped = asMonad(Stream.of(1,2,3)).zip(Stream.of(2,3,4), (a,b) -> Arrays.asList(a,b)); //[[1,2][2,3][3,4]]

Methods inherited from interface com.aol.cyclops.lambda.api.Streamable

getStreamable, iterator, of

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Methods inherited from interface com.aol.cyclops.lambda.api.AsGenericMonad

asMonad, convertToMonad, monad, monad, monad, monad, monad, monad, monad, monad, toMonad

Method Detail

withMonad

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

getMonad

java.lang.Object getMonad()

withFunctor

default <T> Monad<MONAD,T> withFunctor(T functor)

Description copied from interface: Functor

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 Functor<T>

Returns:

getFunctor

default java.lang.Object getFunctor()

Description copied from interface: Functor

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 Functor<T>

Returns:

underlying functor

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<T> fn)

Specified by:

filter in interface Filterable<T>

map

default <R> Monad<MONAD,R> map(java.util.function.Function<T,R> fn)

Specified by:

map in interface Functor<T>

peek

default Monad<MONAD,T> peek(java.util.function.Consumer<T> c)

Specified by:

peek in interface Functor<T>

allMatch

default void allMatch(java.util.function.Predicate<T> c)

True if predicate matches all elements when Monad converted to a Stream

Parameters:

c - Predicate to check if all match

anyMatch

default void anyMatch(java.util.function.Predicate<T> c)

True if a single element matches when Monad converted to a Stream

Parameters:

c - Predicate to check if any match

findFirst

default java.util.Optional<T> findFirst()

Returns:

First matching element in sequential order (deterministic)

findAny

default java.util.Optional<T> findAny()

Returns:

first matching element, but order is not guaranteed (non-deterministic)

bind

default <R> Monad<MONAD,T> bind(java.util.function.Function<T,R> 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 <MONAD1,R> Monad<MONAD1,R> liftAndBind(java.util.function.Function<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

mapReduce

default <R> R mapReduce(Monoid<R> reducer)

Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

mapReduce

default <R> R mapReduce(java.util.function.Function<T,R> mapper,
                        Monoid<R> reducer)

Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values

Parameters:

mapper - Function to map Monad type

reducer - Monoid to reduce values

Returns:

Reduce result

collect

default <R,A> R collect(java.util.stream.Collector<T,A,R> collector)

Mutable reduction / collection over this Monad converted to a Stream

Parameters:

collector - Collection operation definition

Returns:

Collected result

collect

default java.util.List collect(java.util.stream.Stream<java.util.stream.Collector> collectors)

Apply multiple collectors Simulataneously to this Monad List result = monad(Stream.of(1,2,3)).collect(Stream.of(Collectors.toList(), Collectors.summingInt(Integer::intValue), Collectors.averagingInt(Integer::intValue))); assertThat(result.get(0),equalTo(Arrays.asList(1,2,3))); assertThat(result.get(1),equalTo(6)); assertThat(result.get(2),equalTo(2.0)); NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first. I.e. streamedMonad().collect(collectors);

Parameters:

collectors - Stream of Collectors to apply

Returns:

List of results

reduce

default T reduce(Monoid<T> reducer)

NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first. I.e. streamedMonad().reduce(reducer)

Parameters:

reducer - Use supplied Monoid to reduce values

Returns:

reduced values

reduce

default java.util.List<T> reduce(java.util.stream.Stream<Monoid<T>> reducers)

Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first. I.e. streamedMonad().reduce(reducer)

Parameters:

reducers -

Returns:

reduce

default java.util.List<T> reduce(java.lang.Iterable<Monoid<T>> reducers)

Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first. I.e. streamedMonad().reduce(reducer)

Parameters:

reducers -

Returns:

foldLeft

default T foldLeft(Monoid<T> reducer)

Parameters:

reducer - Use supplied Monoid to reduce values starting via foldLeft

Returns:

Reduced result

foldLeftMapToType

default <T> T foldLeftMapToType(Monoid<T> reducer)

Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

foldRight

default T foldRight(Monoid<T> reducer)

Parameters:

reducer - Use supplied Monoid to reduce values starting via foldRight

Returns:

Reduced result

foldRightMapToType

default <T> T foldRightMapToType(Monoid<T> reducer)

Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

toStreamable

default Streamable<T> toStreamable()

Returns:

Underlying monad converted to a Streamable instance

toSet

default java.util.Set<T> toSet()

Returns:

This monad converted to a set

toList

default java.util.List<T> toList()

Returns:

this monad converted to a list

toStream

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

Returns:

calls to stream() but more flexible on type for inferencing purposes.

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 Streamable<T>

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<MONAD,java.util.Optional<R>> fn)

flatMapToStream

default <R> Monad<java.util.stream.Stream<R>,R> flatMapToStream(java.util.function.Function<MONAD,java.util.stream.Stream<R>> fn)

flatMapToCompletableFuture

default <R> Monad<java.util.concurrent.CompletableFuture<R>,R> flatMapToCompletableFuture(java.util.function.Function<MONAD,java.util.concurrent.CompletableFuture<R>> fn)

cycle

default Monad<java.util.stream.Stream<T>,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

cycle

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

Convert to a Stream with the result of a reduction operation repeated specified times List<Integer> list = AsGenericMonad,asMonad(Stream.of(1,2,2)) .cycle(Reducers.toCountInt(),3) .collect(Collectors.toList()); //is asList(3,3,3);

Parameters:

m - Monoid to be used in reduction

times - Number of times value should be repeated

Returns:

Stream with reduced values repeated

cycle

default <R> Monad<java.util.stream.Stream<R>,R> cycle(java.lang.Class<R> monad,
                                                      int times)

Convert to a Stream, repeating the resulting structure specified times and lifting all values to the specified Monad type List<Optional<Integer>> list = monad(Stream.of(1,2)) .cycle(Optional.class,2) .toList(); //is asList(Optional.of(1),Optional.of(2),Optional.of(1),Optional.of(2) ));

Parameters:

monad -

times -

Returns:

cycleWhile

default Monad<java.util.stream.Stream<T>,T> cycleWhile(java.util.function.Predicate<T> predicate)

Repeat in a Stream while specified predicate holds

Parameters:

predicate - repeat while true

Returns:

Repeating Stream

cycleUntil

default Monad<java.util.stream.Stream<T>,T> cycleUntil(java.util.function.Predicate<T> predicate)

Repeat in a Stream until specified predicate holds

Parameters:

predicate - repeat while true

Returns:

Repeating Stream

zip

default <MONAD2,S,R> Monad<java.util.stream.Stream<R>,R> zip(Monad<MONAD2,? extends S> second,
                                                             java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Generic zip function. E.g. Zipping a Stream and an Optional Stream<List<Integer>> zipped = asMonad(Stream.of(1,2,3)).zip(asMonad(Optional.of(2)), (a,b) -> Arrays.asList(a,b)); // [[1,2]]

Parameters:

second - Monad to zip with

zipper - Zipping function

Returns:

Stream zipping two Monads

zip

default <S,R> Monad<java.util.stream.Stream<R>,R> zip(java.util.stream.Stream<? extends S> second,
                                                      java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Zip this Monad with a Stream Stream<List<Integer>> zipped = asMonad(Stream.of(1,2,3)).zip(Stream.of(2,3,4), (a,b) -> Arrays.asList(a,b)); //[[1,2][2,3][3,4]]

Parameters:

second - Stream to zip with

zipper - Zip funciton

Returns:

This monad zipped with a Stream

sliding

default Monad<java.util.stream.Stream<java.util.List<T>>,java.util.List<T>> sliding(int windowSize)

Create a sliding view over this monad

Parameters:

windowSize - Size of sliding window

Returns:

Stream with sliding view over monad

grouped

default Monad<java.util.stream.Stream<java.util.List<T>>,java.util.List<T>> grouped(int groupSize)

Group elements in a Monad into a Stream List<List<Integer>> list = monad(Stream.of(1,2,3,4,5,6)) .grouped(3) .collect(Collectors.toList()); assertThat(list.get(0),hasItems(1,2,3)); assertThat(list.get(1),hasItems(4,5,6));

Parameters:

groupSize - Size of each Group

Returns:

Stream with elements grouped by size

startsWith

default boolean startsWith(java.lang.Iterable<T> iterable)

assertTrue(monad(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3)));

Parameters:

iterable -

Returns:

True if Monad starts with Iterable sequence of data

startsWith

default boolean startsWith(java.util.Iterator<T> iterator)

assertTrue(monad(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3).iterator()))

Parameters:

iterator -

Returns:

True if Monad starts with Iterators sequence of data

distinct

default Monad<java.util.stream.Stream<T>,T> distinct()

scanLeft

default Monad<java.util.stream.Stream<T>,T> scanLeft(Monoid<T> monoid)

Scan left using supplied Monoid assertEquals(asList("", "a", "ab", "abc"),monad(Stream.of("a", "b", "c")).scanLeft(Reducers.toString("")).toList());

Parameters:

monoid -

Returns:

sorted

default Monad<java.util.stream.Stream<T>,T> sorted()

Returns:

Monad converted to Stream via stream() and sorted - to access nested collections in non-Stream monads as a stream use streamedMonad() first e.g. monad(Optional.of(Arrays.asList(1,2,3))).sorted() // Monad[Stream[List[1,2,3]]] monad(Optional.of(Arrays.asList(1,2,3))).streamedMonad().sorted() // Monad[Stream[1,2,3]] assertThat(monad(Stream.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));

sorted

default Monad<java.util.stream.Stream<T>,T> sorted(java.util.Comparator<T> c)

Monad converted to Stream via stream() and sorted - to access nested collections in non-Stream monads as a stream use streamedMonad() first e.g. monad(Optional.of(Arrays.asList(1,2,3))).sorted( (a,b)->b-a) // Monad[Stream[List[1,2,3]]] monad(Optional.of(Arrays.asList(1,2,3))).streamedMonad().sorted( (a,b)->b-a) // Monad[Stream[3,2,1]]

Parameters:

c - Compartor to sort with

Returns:

Sorted Monad

skip

default Monad<java.util.stream.Stream<T>,T> skip(int num)

assertThat(monad(Stream.of(4,3,6,7)).skip(2).toList(),equalTo(Arrays.asList(6,7))); NB to access nested collections in non-Stream monads as a stream use streamedMonad() first

Parameters:

num - Number of elemenets to skip

Returns:

Monad converted to Stream with specified number of elements skipped

skipWhile

default Monad<java.util.stream.Stream<T>,T> skipWhile(java.util.function.Predicate<T> p)

NB to access nested collections in non-Stream monads as a stream use streamedMonad() first assertThat(monad(Stream.of(4,3,6,7)).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));

Parameters:

p - Predicate to skip while true

Returns:

Monad converted to Stream with elements skipped while predicate holds

skipUntil

default Monad<java.util.stream.Stream<T>,T> skipUntil(java.util.function.Predicate<T> p)

NB to access nested collections in non-Stream monads as a stream use streamedMonad() first assertThat(monad(Stream.of(4,3,6,7)).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));

Parameters:

p - Predicate to skip until true

Returns:

Monad converted to Stream with elements skipped until predicate holds

limit

default Monad<java.util.stream.Stream<T>,T> limit(int num)

NB to access nested collections in non-Stream monads as a stream use streamedMonad() first assertThat(monad(Stream.of(4,3,6,7)).limit(2).toList(),equalTo(Arrays.asList(4,3)));

Parameters:

num - Limit element size to num

Returns:

Monad converted to Stream with elements up to num

limitWhile

default Monad<java.util.stream.Stream<T>,T> limitWhile(java.util.function.Predicate<T> p)

NB to access nested collections in non-Stream monads as a stream use streamedMonad() first assertThat(monad(Stream.of(4,3,6,7)).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));

Parameters:

p - Limit while predicate is true

Returns:

Monad converted to Stream with limited elements

limitUntil

default Monad<java.util.stream.Stream<T>,T> limitUntil(java.util.function.Predicate<T> p)

NB to access nested collections in non-Stream monads as a stream use streamedMonad() first assertThat(monad(Stream.of(4,3,6,7)).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3)));

Parameters:

p - Limit until predicate is true

Returns:

Monad converted to Stream with limited elements

applyM

default <NT,R> Monad<NT,R> applyM(Monad<?,java.util.function.Function<T,R>> fn)

Apply function/s inside supplied Monad to data in current Monad e.g. with Streams Simplex<Integer> applied =monad(Stream.of(1,2,3)).applyM(monad(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 Simplex<Integer> applied =monad(Optional.of(2)).applyM(monad(Optional.of( (Integer a)->a+1)) ).simplex(); assertThat(applied.toList(),equalTo(Arrays.asList(3)));

Parameters:

fn -

Returns:

filterM

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

Filter current monad by each element in supplied Monad e.g. Simplex<Stream<Integer>> applied = monad(Stream.of(1,2,3)) .filterM(monad(Streamable.of( (Integer a)->a>5 ,(Integer a) -> a<3))) .simplex(); //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 Simplex<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

unit

default <MONAD,T> MONAD 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

sequenceNative

static <MONAD,MONAD_LIST> MONAD_LIST sequenceNative(java.lang.Class c,
                                                    java.util.List<MONAD> seq)

Convert a list of Monads to a Monad with a List List<CompletableFuture<Integer>> futures; CompletableFuture<List<Integer>> futureList = Monad.sequence(CompletableFuture.class, futures);

Parameters:

c - The type of Monad to convert

seq - List of monads to convert

Returns:

Monad with a List

traverseNative

static <MONAD,MONAD_LIST,R> MONAD_LIST traverseNative(java.lang.Class c,
                                                      java.util.List<MONAD> seq,
                                                      java.util.function.Function<?,R> fn)

Convert a list of Monads to a Monad with a List applying the supplied function in the process List<CompletableFuture<Integer>> futures; CompletableFuture<List<String>> futureList = Monad.traverse(CompletableFuture.class, futures, (Integer i) -> "hello" +i);

Parameters:

c - Monad type to traverse

seq - List of Monads

fn - Function to apply

Returns:

Monad with a list

traverse

static <MONAD,R> Monad<MONAD,java.util.List<R>> traverse(java.lang.Class c,
                                                         java.util.List<?> seq,
                                                         java.util.function.Function<?,R> fn)

Convert a list of Monads to a Monad with a List applying the supplied function in the process List<CompletableFuture<Integer>> futures; Simplex<List<String>> futureList = Monad.traverse(CompletableFuture.class, futures, (Integer i) -> "hello" +i).simplex();

Parameters:

c - Monad type to traverse

seq - List of Monads

fn - Function to apply

Returns:

Monad with a list

sequence

static <MONAD,T> Monad<MONAD,T> sequence(java.lang.Class c,
                                         java.util.List<?> seq)

Convert a list of Monads to a Monad with a List List<CompletableFuture<Integer>> futures; Simplex<List<Integer>> futureList = Monad.sequence(CompletableFuture.class, futures).simplex();

Parameters:

c - The type of Monad to convert

seq - List of monads to convert

Returns:

Monad with a List

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

flatMap

default <R extends MONAD,NT> Monad<R,NT> flatMap(java.util.function.Function<T,R> fn)

flatMap operation

Parameters:

fn -

Returns:

unwrap

default MONAD unwrap()

Specified by:

unwrap in interface Functor<T>

parallel

default <R,NT> Monad<R,NT> parallel()

Returns:

this monad converted to a Parallel Stream, via streamedMonad() wraped in Monad interface

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

simplex

default <X> Simplex<X> simplex()

Returns:

Simplex view on 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();