com.jnape.palatable.lambda.monad

Interface MonadReader<R,A,MR extends MonadReader<R,?,MR>>

Type Parameters:

R - the environment

A - the output

MR - the witness

All Superinterfaces:

Applicative<A,MR>, Functor<A,MR>, Monad<A,MR>

All Known Subinterfaces:

BiMonoidFactory<A,B,C>, BiPredicate<A,B>, BiSemigroupFactory<A,B,C>, Effect<A>, Fn0<A>, Fn1<A,B>, Fn2<A,B,C>, Fn3<A,B,C,D>, Fn4<A,B,C,D,E>, Fn5<A,B,C,D,E,F>, Fn6<A,B,C,D,E,F,G>, Fn7<A,B,C,D,E,F,G,H>, Fn8<A,B,C,D,E,F,G,H,I>, Kleisli<A,B,M,MB>, Monoid<A>, MonoidFactory<A,B>, Predicate<A>, Semigroup<A>, SemigroupFactory<A,B>

All Known Implementing Classes:

Absent, AddAll, All, Alter, And, Any, AutoBracket, Between, Both, Bracket, CartesianProduct, CatMaybes, Clamp, CmpEq, CmpEqBy, Coalesce, Collapse, Collapse, Compose, Compose, Concat, Cons, Constantly, Cycle, Difference, Distinct, Downcast, Drop, DropWhile, Empty, Endo, EndoK, Eq, Filter, Find, First, Flatten, FoldLeft, FoldRight, Force, GroupBy, GT, GTBy, GTE, GTEBy, Head, Id, IfThenElse, InGroupsOf, Init, Inits, Intersection, Intersperse, Into, Into1, Into3, Into4, Into5, Into6, Into7, Into8, Iterate, Join, Last, Last, LazyRec, LeftAll, LeftAll, LeftAny, LeftAny, LiftA2, LiftA3, LiftA4, LiftA5, LiftA6, LiftA7, LT, LTBy, LTE, LTEBy, Magnetize, MagnetizeBy, Map, Matching, Max, MaxBy, Merge, Merge, MergeMaps, Min, MinBy, Not, Occurrences, Or, Over, Partition, Peek, Peek2, Pre, PrependAll, Present, PutAll, RateLimit, Re, ReaderT, ReduceLeft, ReduceRight, Repeat, Replicate, Reverse, RightAll, RightAll, RightAny, RightAny, RunAll, RunAll, ScanLeft, Sequence, Set, Size, Slide, Snoc, Sort, SortBy, SortWith, Span, State, StateT, Tail, Tails, Take, TakeWhile, Times, ToArray, ToCollection, ToMap, Trampoline, Trivial, Tupler2, Uncons, Under, Unfoldr, Union, Until, Upcast, View, Xor, Zip, ZipWith

public interface MonadReader<R,A,MR extends MonadReader<R,?,MR>>
extends Monad<A,MR>

A monad that is capable of reading an environment R and producing a lifted value A. This is strictly less powerful than an Fn1, loosening the requirement on Contravariant (and therefore Profunctor constraints), so is more generally applicable, offering instead a local(Fn1) mechanism for modifying the environment *after* reading it but before running the effect (as opposed to Contravariant functors which may modify their inputs *before* running their effects, and may therefore alter the input types).

Method Summary

Modifier and Type	Method and Description
default <B> MonadReader<R,B,MR>	discardL(Applicative<B,MR> appB) Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
default <B> MonadReader<R,A,MR>	discardR(Applicative<B,MR> appB) Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
<B> MonadReader<R,B,MR>	flatMap(Fn1<? super A,? extends Monad<B,MR>> f) Chain dependent computations that may continue or short-circuit based on previous results.
default <B> MonadReader<R,B,MR>	fmap(Fn1<? super A,? extends B> fn) Covariantly transmute this functor's parameter using the given mapping function.
default <B> Lazy<? extends MonadReader<R,B,MR>>	lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MR>> 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.
MonadReader<R,A,MR>	local(Fn1<? super R,? extends R> fn) Modify this MonadReader's environment after reading it but before running the effect.
<B> MonadReader<R,B,MR>	pure(B b) Lift the value b into this applicative functor.
default <B> MonadReader<R,B,MR>	zip(Applicative<Fn1<? super A,? extends B>,MR> appFn) Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.

Methods inherited from interface com.jnape.palatable.lambda.monad.Monad

join

Methods inherited from interface com.jnape.palatable.lambda.functor.Functor

coerce

Method Detail

local

MonadReader<R,A,MR> local(Fn1<? super R,? extends R> fn)

Modify this MonadReader's environment after reading it but before running the effect.

Parameters:

fn - the modification function

Returns:

the MonadReader with a modified environment

flatMap

<B> MonadReader<R,B,MR> flatMap(Fn1<? super A,? extends Monad<B,MR>> f)

Chain dependent computations that may continue or short-circuit based on previous results.

Specified by:

flatMap in interface Monad<A,MR extends MonadReader<R,?,MR>>

Type Parameters:

B - the resulting monad parameter type

Parameters:

f - the dependent computation over A

Returns:

the new monad instance

pure

<B> MonadReader<R,B,MR> pure(B b)

Lift the value b into this applicative functor.

Specified by:

pure in interface Applicative<A,MR extends MonadReader<R,?,MR>>

Specified by:

pure in interface Monad<A,MR extends MonadReader<R,?,MR>>

Type Parameters:

B - the type of the returned applicative's parameter

Parameters:

b - the value

Returns:

an instance of this applicative over b

fmap

default <B> MonadReader<R,B,MR> fmap(Fn1<? super A,? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function. Generally this method is specialized to return an instance of the class implementing Functor.

Specified by:

fmap in interface Applicative<A,MR extends MonadReader<R,?,MR>>

Specified by:

fmap in interface Functor<A,MR extends MonadReader<R,?,MR>>

Specified by:

fmap in interface Monad<A,MR extends MonadReader<R,?,MR>>

Type Parameters:

B - the new parameter type

Parameters:

fn - the mapping function

Returns:

a functor over B (the new parameter type)

zip

default <B> MonadReader<R,B,MR> zip(Applicative<Fn1<? super A,? extends B>,MR> appFn)

Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.

Specified by:

zip in interface Applicative<A,MR extends MonadReader<R,?,MR>>

Specified by:

zip in interface Monad<A,MR extends MonadReader<R,?,MR>>

Type Parameters:

B - the resulting applicative parameter type

Parameters:

appFn - the other applicative instance

Returns:

the mapped applicative

lazyZip

default <B> Lazy<? extends MonadReader<R,B,MR>> lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MR>> 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. This is useful for applicatives that support lazy evaluation and early termination.

Specified by:

lazyZip in interface Applicative<A,MR extends MonadReader<R,?,MR>>

Specified by:

lazyZip in interface Monad<A,MR extends MonadReader<R,?,MR>>

Type Parameters:

B - the resulting applicative parameter type

Parameters:

lazyAppFn - the lazy other applicative instance

Returns:

the mapped applicative

See Also:

Maybe, Either

discardL

default <B> MonadReader<R,B,MR> discardL(Applicative<B,MR> appB)

Sequence both this Applicative and appB, discarding this Applicative's result and returning appB. This is generally useful for sequentially performing side-effects.

Specified by:

discardL in interface Applicative<A,MR extends MonadReader<R,?,MR>>

Specified by:

discardL in interface Monad<A,MR extends MonadReader<R,?,MR>>

Type Parameters:

B - the type of the returned Applicative's parameter

Parameters:

appB - the other Applicative

Returns:

appB

discardR

default <B> MonadReader<R,A,MR> discardR(Applicative<B,MR> appB)

Sequence both this Applicative and appB, discarding appB's result and returning this Applicative. This is generally useful for sequentially performing side-effects.

Specified by:

discardR in interface Applicative<A,MR extends MonadReader<R,?,MR>>

Specified by:

discardR in interface Monad<A,MR extends MonadReader<R,?,MR>>

Type Parameters:

B - the type of appB's parameter

Parameters:

appB - the other Applicative

Returns:

this Applicative