com.aol.cyclops.control.monads.transformers.seq

Class ReaderTSeq<T,R>

java.lang.Object

com.aol.cyclops.control.monads.transformers.seq.ReaderTSeq<T,R>

Type Parameters:

T - The type contained on the Maybe within

public class ReaderTSeq<T,R>
extends java.lang.Object

Monad transformer for Reader

Method Summary

Modifier and Type	Method and Description
R	apply(T t, Monoid<R> combiner)
<B> ReaderTSeq<T,B>	flatMap(java.util.function.Function<? super R,? extends Reader<T,B>> f)
<B> ReaderTSeq<T,B>	flatMapT(java.util.function.Function<? super R,ReaderTSeq<T,B>> mapper) Flat Map the wrapped Reader
static <T,A> ReaderTSeq<T,A>	fromAnyM(AnyMSeq<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,U,R> java.util.function.Function<ReaderTSeq<T,U>,ReaderTSeq<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<ReaderTSeq<T,U1>,ReaderTSeq<T,U2>,ReaderTSeq<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> ReaderTSeq<T,B>	map(java.util.function.Function<? super R,? extends B> f) Map the wrapped Maybe
static <T,A> ReaderTSeq<T,A>	of(AnyMSeq<Reader<T,A>> monads) Construct an MaybeT from an AnyM that wraps a monad containing Maybes
ReaderTSeq<T,R>	peek(java.util.function.Consumer<? super R> peek) Peek at the current value of the Maybe
ReactiveSeq<R>	streamApply(T t)
java.lang.String	toString()
AnyMSeq<Reader<T,R>>	unwrap()

Methods inherited from class java.lang.Object

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

Method Detail

unwrap

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

Returns:

The wrapped AnyM

peek

public ReaderTSeq<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> ReaderTSeq<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<AnyMSeq<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> ReaderTSeq<T,B> flatMapT(java.util.function.Function<? super R,ReaderTSeq<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> ReaderTSeq<T,B> flatMap(java.util.function.Function<? super R,? extends Reader<T,B>> f)

lift

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

streamApply

public ReactiveSeq<R> streamApply(T t)