EvalT (simple-react 1.0.0-RC2.2 API)

java.lang.Object
- com.aol.cyclops.control.monads.transformers.EvalT<T>

Type Parameters:

T - The type contained on the Maybe within
```
public class EvalT<T>
extends java.lang.Object
```
Monad transformer for JDK Maybe MaybeT consists of an AnyM instance that in turns wraps anoter Monad type that contains an Maybe MaybeT>>> MaybeT allows the deeply wrapped Maybe to be manipulating within it's nested /contained context

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`MaybeT<T>`	`filter(java.util.function.Predicate<? super T> test)` Filter the wrapped Maybe
`<B> EvalT<B>`	`flatMap(java.util.function.Function<? super T,EvalT<? extends B>> f)` Flat Map the wrapped Maybe
`static <A> EvalT<A>`	`fromAnyM(AnyM<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 <U,R> java.util.function.Function<EvalT<U>,EvalT<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 <U1,U2,R> java.util.function.BiFunction<EvalT<U1>,EvalT<U2>,EvalT<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> EvalT<B>`	`map(java.util.function.Function<? super T,? extends B> f)` Map the wrapped Maybe
`static <A> EvalT<A>`	`of(AnyM<Eval<A>> monads)` Construct an MaybeT from an AnyM that wraps a monad containing Maybes
`EvalT<T>`	`peek(java.util.function.Consumer<? super T> peek)` Peek at the current value of the Maybe
`java.lang.String`	`toString()`
`AnyM<Eval<T>>`	`unwrap()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Method Detail

unwrap
```
public AnyM<Eval<T>> unwrap()
```
Returns:

The wrapped AnyM

peek

public EvalT<T> peek(java.util.function.Consumer<? super T> 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

filter

public MaybeT<T> filter(java.util.function.Predicate<? super T> test)

Filter the wrapped Maybe

  
    MaybeT.of(AnyM.fromStream(Maybe.of(10))
             .filter(t->t!=10);
             
     //MaybeT<AnyM<Stream<Maybe.empty>>>

Parameters:: test - Predicate to filter the wrapped Maybe
Returns:: MaybeT that applies the provided filter

map

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

Map the wrapped Maybe

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

Parameters:: f - Mapping function for the wrapped Maybe
Returns:: MaybeT that applies the map function to the wrapped Maybe

flatMap

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

Flat Map the wrapped Maybe

  
  MaybeT.of(AnyM.fromStream(Maybe.of(10))
             .flatMap(t->Maybe.empty();
  
  
  //MaybeT<AnyM<Stream<Maybe.empty>>>

Parameters:: f - FlatMap function
Returns:: MaybeT that applies the flatMap function to the wrapped Maybe

lift

public static <U,R> java.util.function.Function<EvalT<U>,EvalT<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);
     AnyM stream = AnyM.ofMonad(withNulls);
     AnyM> 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 <U1,U2,R> java.util.function.BiFunction<EvalT<U1>,EvalT<U2>,EvalT<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);
     AnyM stream = AnyM.ofMonad(withNulls);
     AnyM> streamOpt = stream.map(Maybe::ofNullable);
 
     CompletableFuture> two = CompletableFuture.supplyAsync(() -> Maybe.of(2));
     AnyM> 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

fromAnyM
```
public static <A> EvalT<A> fromAnyM(AnyM<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 <A> EvalT<A> of(AnyM<Eval<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

Class EvalT<T>

Method Summary

Methods inherited from class java.lang.Object

Method Detail

unwrap

peek

filter

map

flatMap

lift

lift2

fromAnyM

of

toString