R - the input typeM - the returned MonadRecA - the embedded output typepublic final class ReaderT<R,M extends MonadRec<?,M>,A> extends Object implements MonadReader<R,A,ReaderT<R,M,?>>, Cartesian<R,A,ReaderT<?,M,?>>, MonadT<M,A,ReaderT<R,M,?>,ReaderT<R,?,?>>
| Modifier and Type | Method and Description |
|---|---|
ReaderT<R,M,Tuple2<R,A>> |
carry()
Pair the covariantly-positioned carrier type with the contravariantly-positioned carrier type.
|
<C> ReaderT<Tuple2<C,R>,M,Tuple2<C,A>> |
cartesian()
Pair some type
C to this profunctor's carrier types. |
<Q> ReaderT<Q,M,A> |
contraMap(Fn1<? super Q,? extends R> fn)
Contravariantly map
A <- B. |
<Q,B> ReaderT<Q,M,B> |
diMap(Fn1<? super Q,? extends R> lFn,
Fn1<? super A,? extends B> rFn)
Dually map contravariantly over the left parameter and covariantly over the right parameter.
|
<Q> ReaderT<Q,M,A> |
diMapL(Fn1<? super Q,? extends R> fn)
Contravariantly map over the left parameter.
|
<B> ReaderT<R,M,B> |
diMapR(Fn1<? super A,? extends B> fn)
Covariantly map over the right parameter.
|
<B> ReaderT<R,M,B> |
discardL(Applicative<B,ReaderT<R,M,?>> appB)
Sequence both this
Applicative and appB, discarding this Applicative's
result and returning appB. |
<B> ReaderT<R,M,A> |
discardR(Applicative<B,ReaderT<R,M,?>> appB)
Sequence both this
Applicative and appB, discarding appB's result and
returning this Applicative. |
<B> ReaderT<R,M,B> |
flatMap(Fn1<? super A,? extends Monad<B,ReaderT<R,M,?>>> f)
Chain dependent computations that may continue or short-circuit based on previous results.
|
<B> ReaderT<R,M,B> |
fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.
|
<B> Lazy<ReaderT<R,M,B>> |
lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,ReaderT<R,M,?>>> lazyAppFn)
Given a
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. |
<B,N extends MonadRec<?,N>> |
lift(MonadRec<B,N> mb)
|
static <R> Lift<ReaderT<R,?,?>> |
liftReaderT()
|
ReaderT<R,M,A> |
local(Fn1<? super R,? extends R> fn)
Modify this
MonadReader's environment after reading it but before running the effect. |
<MA extends MonadRec<A,M>,N extends MonadRec<?,N>,B> |
mapReaderT(Fn1<? super MA,? extends MonadRec<B,N>> fn)
|
<B> ReaderT<R,M,B> |
pure(B b)
Lift the value
b into this applicative functor. |
static <R,M extends MonadRec<?,M>> |
pureReaderT(Pure<M> pureM)
|
static <R,M extends MonadRec<?,M>,A> |
readerT(Fn1<? super R,? extends MonadRec<A,M>> fn)
|
<MA extends MonadRec<A,M>> |
runReaderT(R r)
Run the computation represented by this
ReaderT. |
<B> ReaderT<R,M,B> |
trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,ReaderT<R,M,?>>> fn)
Given some operation yielding a
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction. |
<B> ReaderT<R,M,B> |
zip(Applicative<Fn1<? super A,? extends B>,ReaderT<R,M,?>> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using
whatever application semantics the current applicative supports.
|
public <MA extends MonadRec<A,M>> MA runReaderT(R r)
ReaderT.MA - the witnessed target typer - the inputMonadRecpublic <MA extends MonadRec<A,M>,N extends MonadRec<?,N>,B> ReaderT<R,N,B> mapReaderT(Fn1<? super MA,? extends MonadRec<B,N>> fn)
public ReaderT<R,M,A> local(Fn1<? super R,? extends R> fn)
MonadReader's environment after reading it but before running the effect.local in interface MonadReader<R,A,ReaderT<R,M extends MonadRec<?,M>,?>>fn - the modification functionMonadReader with a modified environmentpublic <B,N extends MonadRec<?,N>> ReaderT<R,N,B> lift(MonadRec<B,N> mb)
lift in interface MonadBase<M extends MonadRec<?,M>,A,ReaderT<R,?,?>>lift in interface MonadT<M extends MonadRec<?,M>,A,ReaderT<R,M extends MonadRec<?,M>,?>,ReaderT<R,?,?>>B - the MonadRec carrier typeN - the argument MonadRec witnessmb - the argument MonadRecMonadBasepublic <B> ReaderT<R,M,B> flatMap(Fn1<? super A,? extends Monad<B,ReaderT<R,M,?>>> f)
flatMap in interface Monad<A,ReaderT<R,M extends MonadRec<?,M>,?>>flatMap in interface MonadReader<R,A,ReaderT<R,M extends MonadRec<?,M>,?>>flatMap in interface MonadRec<A,ReaderT<R,M extends MonadRec<?,M>,?>>flatMap in interface MonadT<M extends MonadRec<?,M>,A,ReaderT<R,M extends MonadRec<?,M>,?>,ReaderT<R,?,?>>B - the resulting monad parameter typef - the dependent computation over Apublic <B> ReaderT<R,M,B> trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,ReaderT<R,M,?>>> fn)
RecursiveResult inside this MonadRec, internally trampoline the
operation until it yields a termination instruction.
Stack-safety depends on implementations guaranteeing that the growth of the call stack is a constant factor independent of the number of invocations of the operation. For various examples of how this can be achieved in stereotypical circumstances, see the referenced types.
trampolineM in interface MonadRec<A,ReaderT<R,M extends MonadRec<?,M>,?>>B - the ultimate resulting carrier typefn - the function to internally trampolineMonadRecfor a basic implementation,
for a {@link CoProduct2 coproduct} implementation,
for an implementation leveraging an already stack-safe {@link Monad#flatMap(Fn1)},
for a {@link MonadT monad transformer} implementationpublic <B> ReaderT<R,M,B> pure(B b)
b into this applicative functor.pure in interface Applicative<A,ReaderT<R,M extends MonadRec<?,M>,?>>pure in interface Monad<A,ReaderT<R,M extends MonadRec<?,M>,?>>pure in interface MonadReader<R,A,ReaderT<R,M extends MonadRec<?,M>,?>>pure in interface MonadRec<A,ReaderT<R,M extends MonadRec<?,M>,?>>pure in interface MonadT<M extends MonadRec<?,M>,A,ReaderT<R,M extends MonadRec<?,M>,?>,ReaderT<R,?,?>>B - the type of the returned applicative's parameterb - the valuepublic <B> ReaderT<R,M,B> fmap(Fn1<? super A,? extends B> fn)
fmap in interface Applicative<A,ReaderT<R,M extends MonadRec<?,M>,?>>fmap in interface Functor<A,ReaderT<R,M extends MonadRec<?,M>,?>>fmap in interface Monad<A,ReaderT<R,M extends MonadRec<?,M>,?>>fmap in interface MonadReader<R,A,ReaderT<R,M extends MonadRec<?,M>,?>>fmap in interface MonadRec<A,ReaderT<R,M extends MonadRec<?,M>,?>>fmap in interface MonadT<M extends MonadRec<?,M>,A,ReaderT<R,M extends MonadRec<?,M>,?>,ReaderT<R,?,?>>B - the new parameter typefn - the mapping functionpublic <B> ReaderT<R,M,B> zip(Applicative<Fn1<? super A,? extends B>,ReaderT<R,M,?>> appFn)
zip in interface Applicative<A,ReaderT<R,M extends MonadRec<?,M>,?>>zip in interface Monad<A,ReaderT<R,M extends MonadRec<?,M>,?>>zip in interface MonadReader<R,A,ReaderT<R,M extends MonadRec<?,M>,?>>zip in interface MonadRec<A,ReaderT<R,M extends MonadRec<?,M>,?>>zip in interface MonadT<M extends MonadRec<?,M>,A,ReaderT<R,M extends MonadRec<?,M>,?>,ReaderT<R,?,?>>B - the resulting applicative parameter typeappFn - the other applicative instancepublic <B> Lazy<ReaderT<R,M,B>> lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,ReaderT<R,M,?>>> lazyAppFn)
lazy instance of this applicative over a mapping function, "zip" the two instances together
using whatever application semantics the current applicative supports. This is useful for applicatives that
support lazy evaluation and early termination.lazyZip in interface Applicative<A,ReaderT<R,M extends MonadRec<?,M>,?>>lazyZip in interface Monad<A,ReaderT<R,M extends MonadRec<?,M>,?>>lazyZip in interface MonadReader<R,A,ReaderT<R,M extends MonadRec<?,M>,?>>lazyZip in interface MonadRec<A,ReaderT<R,M extends MonadRec<?,M>,?>>lazyZip in interface MonadT<M extends MonadRec<?,M>,A,ReaderT<R,M extends MonadRec<?,M>,?>,ReaderT<R,?,?>>B - the resulting applicative parameter typelazyAppFn - the lazy other applicative instanceMaybe,
Eitherpublic <B> ReaderT<R,M,B> discardL(Applicative<B,ReaderT<R,M,?>> appB)
Applicative and appB, discarding this Applicative's
result and returning appB. This is generally useful for sequentially performing side-effects.discardL in interface Applicative<A,ReaderT<R,M extends MonadRec<?,M>,?>>discardL in interface Monad<A,ReaderT<R,M extends MonadRec<?,M>,?>>discardL in interface MonadReader<R,A,ReaderT<R,M extends MonadRec<?,M>,?>>discardL in interface MonadRec<A,ReaderT<R,M extends MonadRec<?,M>,?>>discardL in interface MonadT<M extends MonadRec<?,M>,A,ReaderT<R,M extends MonadRec<?,M>,?>,ReaderT<R,?,?>>B - the type of the returned Applicative's parameterappB - the other Applicativepublic <B> ReaderT<R,M,A> discardR(Applicative<B,ReaderT<R,M,?>> appB)
Applicative and appB, discarding appB's result and
returning this Applicative. This is generally useful for sequentially performing side-effects.discardR in interface Applicative<A,ReaderT<R,M extends MonadRec<?,M>,?>>discardR in interface Monad<A,ReaderT<R,M extends MonadRec<?,M>,?>>discardR in interface MonadReader<R,A,ReaderT<R,M extends MonadRec<?,M>,?>>discardR in interface MonadRec<A,ReaderT<R,M extends MonadRec<?,M>,?>>discardR in interface MonadT<M extends MonadRec<?,M>,A,ReaderT<R,M extends MonadRec<?,M>,?>,ReaderT<R,?,?>>B - the type of appB's parameterappB - the other Applicativepublic <Q,B> ReaderT<Q,M,B> diMap(Fn1<? super Q,? extends R> lFn, Fn1<? super A,? extends B> rFn)
diMapL(lFn).diMapR(rFn).diMap in interface Cartesian<R,A,ReaderT<?,M extends MonadRec<?,M>,?>>diMap in interface Profunctor<R,A,ReaderT<?,M extends MonadRec<?,M>,?>>Q - the new left parameter typeB - the new right parameter typelFn - the left parameter mapping functionrFn - the right parameter mapping functionpublic <Q> ReaderT<Q,M,A> diMapL(Fn1<? super Q,? extends R> fn)
diMapL in interface Cartesian<R,A,ReaderT<?,M extends MonadRec<?,M>,?>>diMapL in interface Profunctor<R,A,ReaderT<?,M extends MonadRec<?,M>,?>>Q - the new left parameter typefn - the mapping functionpublic <B> ReaderT<R,M,B> diMapR(Fn1<? super A,? extends B> fn)
diMapR(f) == fmap(f).diMapR in interface Cartesian<R,A,ReaderT<?,M extends MonadRec<?,M>,?>>diMapR in interface Profunctor<R,A,ReaderT<?,M extends MonadRec<?,M>,?>>B - the new right parameter typefn - the mapping functionpublic <Q> ReaderT<Q,M,A> contraMap(Fn1<? super Q,? extends R> fn)
A <- B.contraMap in interface Cartesian<R,A,ReaderT<?,M extends MonadRec<?,M>,?>>contraMap in interface Contravariant<R,Profunctor<?,A,ReaderT<?,M extends MonadRec<?,M>,?>>>contraMap in interface Profunctor<R,A,ReaderT<?,M extends MonadRec<?,M>,?>>Q - the new parameter typefn - the mapping functionpublic <C> ReaderT<Tuple2<C,R>,M,Tuple2<C,A>> cartesian()
C to this profunctor's carrier types.public ReaderT<R,M,Tuple2<R,A>> carry()
public static <R,M extends MonadRec<?,M>,A> ReaderT<R,M,A> readerT(Fn1<? super R,? extends MonadRec<A,M>> fn)
public static <R,M extends MonadRec<?,M>> Pure<ReaderT<R,M,?>> pureReaderT(Pure<M> pureM)