Uses of Class
com.jnape.palatable.lambda.functor.builtin.State

Packages that use State
Package
Description
com.jnape.palatable.lambda.functor.builtin
 

  • Uses of State in com.jnape.palatable.lambda.functor.builtin

    Classes in com.jnape.palatable.lambda.functor.builtin that implement interfaces with type arguments of type State
    Modifier and Type
    Class
    Description
    final class 
    State<S,A>
    The state Monad, useful for iteratively building up state and state-contextualized result.
    final class 
    State<S,A>
    The state Monad, useful for iteratively building up state and state-contextualized result.
    final class 
    State<S,A>
    The state Monad, useful for iteratively building up state and state-contextualized result.
    Methods in com.jnape.palatable.lambda.functor.builtin that return State
    Modifier and Type
    Method
    Description
    State<S,A>
    State.censor(Fn1<? super S, ? extends S> fn)
    Update the accumulated state.
    <B> State<S,B>
    State.discardL(Applicative<B, State<S,?>> appB)
    Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
    <B> State<S,A>
    State.discardR(Applicative<B, State<S,?>> appB)
    Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
    <B> State<S,B>
    State.flatMap(Fn1<? super A, ? extends Monad<B, State<S,?>>> f)
    Chain dependent computations that may continue or short-circuit based on previous results.
    <B> State<S,B>
    State.fmap(Fn1<? super A, ? extends B> fn)
    Covariantly transmute this functor's parameter using the given mapping function.
    static <A> State<A,A>
    State.get()
    Create a State that simply returns back the initial state as both the result and the final state
    static <S,A> State<S,A>
    State.gets(Fn1<? super S, ? extends A> fn)
    Create a State that maps its initial state into its result, but leaves the initial state unchanged.
    <B> State<S, Tuple2<A,B>>
    State.listens(Fn1<? super S, ? extends B> fn)
    Map the accumulation into a value and pair it with the current output.
    State<S,A>
    State.local(Fn1<? super S, ? extends S> fn)
    Modify this MonadReader's environment after reading it but before running the effect.
    <B> State<S,B>
    State.mapState(Fn1<? super Tuple2<A,S>, ? extends Tuple2<B,S>> fn)
    Map both the result and the final state to a new result and final state.
    static <S> State<S,Unit>
    State.modify(Fn1<? super S, ? extends S> fn)
    Create a State that maps its initial state into its final state, returning a Unit result type.
    <B> State<S,B>
    State.pure(B b)
    Lift the value b into this applicative functor.
    static <S> State<S,Unit>
    State.put(S s)
    Create a State that ignores its initial state, returning a Unit result and s as its final state.
    static <S,A> State<S,A>
    State.state(A a)
    Create a State that returns a as its result and its initial state as its final state.
    static <S,A> State<S,A>
    State.state(Fn1<? super S, ? extends Tuple2<A,S>> stateFn)
    Create a State from stateFn, a function that maps an initial state into a result and a final state.
    <B> State<S,B>
    State.trampolineM(Fn1<? super A, ? extends MonadRec<RecursiveResult<A,B>, State<S,?>>> fn)
    Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.
    State<S,A>
    State.withState(Fn1<? super S, ? extends S> fn)
    Map the final state to a new final state using the provided function.
    <B> State<S,B>
    State.zip(Applicative<Fn1<? super A, ? extends B>, State<S,?>> 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.functor.builtin that return types with arguments of type State
    Modifier and Type
    Method
    Description
    <B> Lazy<State<S,B>>
    State.lazyZip(Lazy<? extends Applicative<Fn1<? super A, ? extends B>, State<S,?>>> 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> Pure<State<S,?>>
    State.pureState()
    The canonical Pure instance for State.
    Method parameters in com.jnape.palatable.lambda.functor.builtin with type arguments of type State
    Modifier and Type
    Method
    Description
    <B> State<S,B>
    State.discardL(Applicative<B, State<S,?>> appB)
    Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
    <B> State<S,A>
    State.discardR(Applicative<B, State<S,?>> appB)
    Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
    <B> State<S,B>
    State.flatMap(Fn1<? super A, ? extends Monad<B, State<S,?>>> f)
    Chain dependent computations that may continue or short-circuit based on previous results.
    <B> Lazy<State<S,B>>
    State.lazyZip(Lazy<? extends Applicative<Fn1<? super A, ? extends B>, State<S,?>>> 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> State<S,B>
    State.trampolineM(Fn1<? super A, ? extends MonadRec<RecursiveResult<A,B>, State<S,?>>> fn)
    Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.
    <B> State<S,B>
    State.zip(Applicative<Fn1<? super A, ? extends B>, State<S,?>> appFn)
    Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.