com.aol.cyclops.control.monads.transformers.values

Class ReaderTValue<T,R>

java.lang.Object

com.aol.cyclops.control.monads.transformers.values.ReaderTValue<T,R>

Type Parameters:

T - The type contained on the Maybe within

All Implemented Interfaces:

java.util.function.Function<T,R>

public class ReaderTValue<T,R>
extends java.lang.Object
implements java.util.function.Function<T,R>

Monad transformer for Reader

Method Summary

Modifier and Type	Method and Description
R	apply(T t)
boolean	equals(java.lang.Object o)
<B> ReaderTValue<T,B>	flatMap(java.util.function.Function<? super R,? extends Reader<T,B>> f)
<B> ReaderTValue<T,B>	flatMapT(java.util.function.Function<? super R,ReaderTValue<T,B>> mapper) Flat Map the wrapped Reader
static <T,A> ReaderTValue<T,A>	fromAnyM(AnyMValue<java.util.function.Function<T,A>> anyM) Construct an MaybeT from an AnyM that contains a monad type that contains type other than Maybe The values in the underlying monad will be mapped to Maybe
static <T,A,V extends MonadicValue<Reader<T,A>>> ReaderTValue<T,A>	fromValue(V monadicValue)
int	hashCode()
static <T,U,R> java.util.function.Function<ReaderTValue<T,U>,ReaderTValue<T,R>>	lift(java.util.function.Function<? super U,? extends R> fn) Lift a function into one that accepts and returns an MaybeT This allows multiple monad types to add functionality to existing functions and methods e.g.
static <T,U1,U2,R> java.util.function.BiFunction<ReaderTValue<T,U1>,ReaderTValue<T,U2>,ReaderTValue<T,R>>	lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn) Lift a BiFunction into one that accepts and returns MaybeTs This allows multiple monad types to add functionality to existing functions and methods e.g.
<B> ReaderTValue<T,B>	map(java.util.function.Function<? super R,? extends B> f) Map the wrapped Maybe
Maybe<R>	maybeApply(T t)
static <T,A> ReaderTValue<T,A>	of(AnyMValue<Reader<T,A>> monads) Construct an MaybeT from an AnyM that wraps a monad containing Maybes
ReaderTValue<T,R>	peek(java.util.function.Consumer<? super R> peek) Peek at the current value of the Maybe
java.lang.String	toString()
AnyMValue<Reader<T,R>>	unwrap()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.function.Function

andThen, compose, identity

Method Detail

unwrap

public AnyMValue<Reader<T,R>> unwrap()

Returns:

The wrapped AnyM

peek

public ReaderTValue<T,R> peek(java.util.function.Consumer<? super R> peek)

Peek at the current value of the Maybe

  
    MaybeT.of(AnyM.fromStream(Maybe.of(10))
             .peek(System.out::println);
             
     //prints 10        
 
 

Parameters:

peek - Consumer to accept current value of Maybe

Returns:

MaybeT with peek call

map

public <B> ReaderTValue<T,B> map(java.util.function.Function<? super R,? extends B> f)

Map the wrapped Maybe

  
  MaybeT.of(AnyM.fromStream(Maybe.of(10))
             .map(t->t=t+1);
  
  
  //MaybeT<AnyMValue<Stream<Maybe[11]>>>
 
 

Parameters:

f - Mapping function for the wrapped Maybe

Returns:

MaybeT that applies the map function to the wrapped Maybe

flatMapT

public <B> ReaderTValue<T,B> flatMapT(java.util.function.Function<? super R,ReaderTValue<T,B>> mapper)

Flat Map the wrapped Reader

Parameters:

f - FlatMap function

Returns:

ReaderT that applies the flatMap function to the wrapped Maybe

flatMap

public <B> ReaderTValue<T,B> flatMap(java.util.function.Function<? super R,? extends Reader<T,B>> f)

lift

public static <T,U,R> java.util.function.Function<ReaderTValue<T,U>,ReaderTValue<T,R>> lift(java.util.function.Function<? super U,? extends R> fn)

Lift a function into one that accepts and returns an MaybeT This allows multiple monad types to add functionality to existing functions and methods e.g. to add null handling (via Maybe) and iteration (via Stream) to an existing function

 {
     @code
     Function add2 = i -> i + 2;
     Function, MaybeT> optTAdd2 = MaybeT.lift(add2);
 
     Stream withNulls = Stream.of(1, 2, null);
     AnyMValue stream = AnyM.ofMonad(withNulls);
     AnyMValue> streamOpt = stream.map(Maybe::ofNullable);
     List results = optTAdd2.apply(MaybeT.of(streamOpt)).unwrap().>> unwrap()
             .filter(Maybe::isPresent).map(Maybe::get).collect(Collectors.toList());
 
     // Arrays.asList(3,4);
 
 }
 

Parameters:

fn - Function to enhance with functionality from Maybe and another monad type

Returns:

Function that accepts and returns an MaybeT

lift2

public static <T,U1,U2,R> java.util.function.BiFunction<ReaderTValue<T,U1>,ReaderTValue<T,U2>,ReaderTValue<T,R>> lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)

Lift a BiFunction into one that accepts and returns MaybeTs This allows multiple monad types to add functionality to existing functions and methods e.g. to add null handling (via Maybe), iteration (via Stream) and asynchronous execution (CompletableFuture) to an existing function

 {
     @code
     BiFunction add = (a, b) -> a + b;
     BiFunction, MaybeT, MaybeT> optTAdd2 = MaybeT.lift2(add);
 
     Stream withNulls = Stream.of(1, 2, null);
     AnyMValue stream = AnyM.ofMonad(withNulls);
     AnyMValue> streamOpt = stream.map(Maybe::ofNullable);
 
     CompletableFuture> two = CompletableFuture.supplyAsync(() -> Maybe.of(2));
     AnyMValue> future = AnyM.ofMonad(two);
     List results = optTAdd2.apply(MaybeT.of(streamOpt), MaybeT.of(future)).unwrap()
             .>> unwrap().filter(Maybe::isPresent).map(Maybe::get)
             .collect(Collectors.toList());
     // Arrays.asList(3,4);
 }
 

Parameters:

fn - BiFunction to enhance with functionality from Maybe and another monad type

Returns:

Function that accepts and returns an MaybeT

fromValue

public static <T,A,V extends MonadicValue<Reader<T,A>>> ReaderTValue<T,A> fromValue(V monadicValue)

fromAnyM

public static <T,A> ReaderTValue<T,A> fromAnyM(AnyMValue<java.util.function.Function<T,A>> anyM)

Construct an MaybeT from an AnyM that contains a monad type that contains type other than Maybe The values in the underlying monad will be mapped to Maybe

Parameters:

anyM - AnyM that doesn't contain a monad wrapping an Maybe

Returns:

MaybeT

of

public static <T,A> ReaderTValue<T,A> of(AnyMValue<Reader<T,A>> monads)

Construct an MaybeT from an AnyM that wraps a monad containing Maybes

Parameters:

monads - AnyM that contains a monad wrapping an Maybe

Returns:

MaybeT

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

apply

public R apply(T t)

Specified by:

apply in interface java.util.function.Function<T,R>

maybeApply

public Maybe<R> maybeApply(T t)

hashCode

public int hashCode()

Overrides:

hashCode in class java.lang.Object

equals

public boolean equals(java.lang.Object o)

Overrides:

equals in class java.lang.Object