com.aol.cyclops.internal.monads

Class BaseAnyMImpl<T>

java.lang.Object

com.aol.cyclops.internal.monads.BaseAnyMImpl<T>

Type Parameters:

T -

Direct Known Subclasses:

AnyMSeqImpl, AnyMValueImpl

public abstract class BaseAnyMImpl<T>
extends java.lang.Object

Wrapper for Any Monad type

See Also:

companion class for static helper methods

Field Summary

Fields

Modifier and Type	Field and Description
protected java.lang.Class	initialType
protected Monad<T>	monad

Constructor Summary

Constructors

Constructor and Description
BaseAnyMImpl()

Method Summary

Modifier and Type	Method and Description
protected AnyM<java.util.List<T>>	aggregate(AnyM<T> next) Aggregate the contents of this Monad and the supplied Monad
ReactiveSeq<T>	asSequence() Wrap this Monad's contents as a Sequence without disaggreating it.
protected <R> Monad<R>	bindInternal(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
abstract <T> AnyM<T>	empty()
protected Monad<T>	filterInternal(java.util.function.Predicate<? super T> fn)
protected <R> Monad<R>	flatMapInternal(java.util.function.Function<? super T,? extends AnyM<? extends R>> fn)
protected <T1> Monad<T1>	flattenInternal() join / flatten one level of a nested hierarchy
void	forEach(java.util.function.Consumer<? super T> action)
T	get()
protected <R> Monad<R>	mapInternal(java.util.function.Function<? super T,? extends R> fn)
Monad	monad()
protected Monad<T>	peekInternal(java.util.function.Consumer<? super T> c)
AnyMSeq<T>	reduceMSeq(Monoid<AnyMSeq<T>> reducer)
AnyMValue<T>	reduceMValue(Monoid<AnyMValue<T>> reducer)
ReactiveSeq<T>	stream()
java.util.List<T>	toList()
<T> ReactiveSeq<T>	toSequence() Optional<List<Integer>> into Stream<Integer>
<NT> ReactiveSeq<NT>	toSequence(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends NT>> fn) Sequence the contents of a Monad.
java.util.Set<T>	toSet()
java.lang.String	toString()
abstract <T> AnyM<T>	unit(T value)
<R> R	unwrap()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

monad

protected final Monad<T> monad

initialType

protected final java.lang.Class initialType

Constructor Detail

BaseAnyMImpl

public BaseAnyMImpl()

Method Detail

unwrap

public <R> R unwrap()

monad

public Monad monad()

filterInternal

protected Monad<T> filterInternal(java.util.function.Predicate<? super T> fn)

mapInternal

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

peekInternal

protected Monad<T> peekInternal(java.util.function.Consumer<? super T> c)

bindInternal

protected <R> Monad<R> bindInternal(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

flatMapInternal

protected <R> Monad<R> flatMapInternal(java.util.function.Function<? super T,? extends AnyM<? extends R>> fn)

flattenInternal

protected <T1> Monad<T1> flattenInternal()

join / flatten one level of a nested hierarchy

Returns:

Flattened / joined one level

aggregate

protected AnyM<java.util.List<T>> aggregate(AnyM<T> next)

Aggregate the contents of this Monad and the supplied Monad

 
 
 List<Integer> result = anyM(Stream.of(1,2,3,4))
 							.aggregate(anyM(Optional.of(5)))
 							.asSequence()
 							.toList();
		
		assertThat(result,equalTo(Arrays.asList(1,2,3,4,5)));
		

Parameters:

next - Monad to aggregate content with

Returns:

Aggregated Monad

forEach

public void forEach(java.util.function.Consumer<? super T> action)

toSequence

public <NT> ReactiveSeq<NT> toSequence(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends NT>> fn)

Sequence the contents of a Monad. e.g. Turn an

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

 List<Integer> list = anyM(Optional.of(Arrays.asList(1,2,3,4,5,6)))
											.<Integer>toSequence(c->c.stream())
											.collect(Collectors.toList());
		
		
		assertThat(list,hasItems(1,2,3,4,5,6));
		
 
 

Returns:

A Sequence that wraps a Stream

toSequence

public <T> ReactiveSeq<T> toSequence()

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

Less type safe equivalent, but may be more accessible than toSequence(fn) i.e.

  
    toSequence(Function<T,Stream<NT>> fn)
   
   

 List<Integer> list = anyM(Optional.of(Arrays.asList(1,2,3,4,5,6)))
											.<Integer>toSequence()
											.collect(Collectors.toList());
		
		
		
 
 

Returns:

A Sequence that wraps a Stream

asSequence

public ReactiveSeq<T> asSequence()

Wrap this Monad's contents as a Sequence without disaggreating it. .e.

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

If the underlying monad is a Stream it is returned Otherwise we flatMap the underlying monad to a Stream type

unit

public abstract <T> AnyM<T> unit(T value)

empty

public abstract <T> AnyM<T> empty()

reduceMValue

public AnyMValue<T> reduceMValue(Monoid<AnyMValue<T>> reducer)

reduceMSeq

public AnyMSeq<T> reduceMSeq(Monoid<AnyMSeq<T>> reducer)

stream

public ReactiveSeq<T> stream()

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

toList

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

toSet

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

get

public T get()