Uses of Class
com.jnape.palatable.lambda.monad.transformer.builtin.StateT

Packages that use StateT

Package	Description
com.jnape.palatable.lambda.functor.builtin
com.jnape.palatable.lambda.monad.transformer.builtin

Uses of StateT in com.jnape.palatable.lambda.functor.builtin

Fields in com.jnape.palatable.lambda.functor.builtin declared as StateT

Modifier and Type	Field	Description
private final StateT<S,Identity<?>,A>	State.stateFn

Constructors in com.jnape.palatable.lambda.functor.builtin with parameters of type StateT

Modifier	Constructor	Description
private	State(StateT<S,Identity<?>,A> stateFn)

Uses of StateT in com.jnape.palatable.lambda.monad.transformer.builtin

Methods in com.jnape.palatable.lambda.monad.transformer.builtin that return StateT

Modifier and Type	Method	Description
StateT<S,M,A>	StateT.censor(Fn1<? super S,? extends S> fn)	Update the accumulated state.
<B> StateT<S,M,B>	StateT.discardL(Applicative<B,StateT<S,M,?>> appB)	Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
<B> StateT<S,M,A>	StateT.discardR(Applicative<B,StateT<S,M,?>> appB)	Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
<B> StateT<S,M,B>	StateT.flatMap(Fn1<? super A,? extends Monad<B,StateT<S,M,?>>> f)	Chain dependent computations that may continue or short-circuit based on previous results.
<B> StateT<S,M,B>	StateT.fmap(Fn1<? super A,? extends B> fn)	Covariantly transmute this functor's parameter using the given mapping function.
static <A, M extends MonadRec<?, M>> StateT<A,M,A>	StateT.get(Pure<M> pureM)	Given a pure construction of some Monad, produce a StateT that equates its output with its state.
static <S, M extends MonadRec<?, M>, A> StateT<S,M,A>	StateT.gets(Fn1<? super S,? extends MonadRec<A,M>> fn)	Given a function that produces a value inside a monadic effect from a state, produce a StateT that simply passes its state to the function and applies it.
<B, N extends MonadRec<?, N>> StateT<S,N,B>	StateT.lift(MonadRec<B,N> mb)	Lift a new argument MonadRec into this MonadBase.
<B> StateT<S,M,Tuple2<A,B>>	StateT.listens(Fn1<? super S,? extends B> fn)	Map the accumulation into a value and pair it with the current output.
StateT<S,M,A>	StateT.local(Fn1<? super S,? extends S> fn)	Modify this MonadReader's environment after reading it but before running the effect.
<N extends MonadRec<?, N>, B> StateT<S,N,B>	StateT.mapStateT(Fn1<? super MonadRec<Tuple2<A,S>,M>,? extends MonadRec<Tuple2<B,S>,N>> fn)	Map both the result and the final state to a new result and final state inside the Monad.
static <S, M extends MonadRec<?, M>> StateT<S,M,Unit>	StateT.modify(Fn1<? super S,? extends MonadRec<S,M>> updateFn)	Lift a function that makes a stateful modification inside an Monad into StateT.
<B> StateT<S,M,B>	StateT.pure(B b)	Lift the value b into this applicative functor.
static <S, M extends MonadRec<?, M>> StateT<S,M,Unit>	StateT.put(MonadRec<S,M> ms)	Lift a monadic state into StateT.
static <S, M extends MonadRec<?, M>, A> StateT<S,M,A>	StateT.stateT(Fn1<? super S,? extends MonadRec<Tuple2<A,S>,M>> stateFn)	Lift a state-sensitive monadically embedded computation into StateT.
static <S, M extends MonadRec<?, M>, A> StateT<S,M,A>	StateT.stateT(MonadRec<A,M> ma)	Lift a monadic value into StateT.
<B> StateT<S,M,B>	StateT.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,StateT<S,M,?>>> fn)	Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.
StateT<S,M,A>	StateT.withStateT(Fn1<? super S,? extends MonadRec<S,M>> fn)	Map the final state to a new final state inside the same monadic effect using the provided function.
<B> StateT<S,M,B>	StateT.zip(Applicative<Fn1<? super A,? extends B>,StateT<S,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.

Methods in com.jnape.palatable.lambda.monad.transformer.builtin that return types with arguments of type StateT

Modifier and Type	Method	Description
<B> Lazy<StateT<S,M,B>>	StateT.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,StateT<S,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.
static <S> Lift<StateT<S,?,?>>	StateT.liftStateT()	Lift for StateT.
static <S, M extends MonadRec<?, M>> Pure<StateT<S,M,?>>	StateT.pureStateT(Pure<M> pureM)	The canonical Pure instance for StateT.

Method parameters in com.jnape.palatable.lambda.monad.transformer.builtin with type arguments of type StateT

Modifier and Type	Method	Description
<B> StateT<S,M,B>	StateT.discardL(Applicative<B,StateT<S,M,?>> appB)	Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
<B> StateT<S,M,A>	StateT.discardR(Applicative<B,StateT<S,M,?>> appB)	Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
<B> StateT<S,M,B>	StateT.flatMap(Fn1<? super A,? extends Monad<B,StateT<S,M,?>>> f)	Chain dependent computations that may continue or short-circuit based on previous results.
<B> Lazy<StateT<S,M,B>>	StateT.lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,StateT<S,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> StateT<S,M,B>	StateT.trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,StateT<S,M,?>>> fn)	Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.
<B> StateT<S,M,B>	StateT.zip(Applicative<Fn1<? super A,? extends B>,StateT<S,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.