com.github.tonivade.purefun.monad

Interface State<S,A>

All Superinterfaces:

FlatMap2<State.µ,S,A>, Higher1<Higher1<State.µ,S>,A>, Higher2<State.µ,S,A>, Kind, Mappable<Higher1<State.µ,S>,A>

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface State<S,A>
extends FlatMap2<State.µ,S,A>

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	State.µ

Method Summary

Modifier and Type	Method and Description
static <S,A> State<S,Sequence<A>>	compose(Sequence<State<S,A>> states)
default A	eval(S state)
default <R> State<S,R>	flatMap(Function1<A,? extends Higher2<State.µ,S,R>> mapper)
static <S> State<S,S>	get()
static <S,A> State<S,A>	inspect(Function1<S,A> mapper)
default <R> State<S,R>	map(Function1<A,R> mapper)
static <S,A,B,C> State<S,C>	map2(State<S,A> sa, State<S,B> sb, Function2<A,B,C> mapper)
static <S> State<S,Nothing>	modify(Operator1<S> mapper)
static <V> Monad<Higher1<State.µ,V>>	monad()
static <S,A> State<S,A>	narrowK(Higher1<Higher1<State.µ,S>,A> hkt)
static <S,A> State<S,A>	narrowK(Higher2<State.µ,S,A> hkt)
static <S,A> State<S,A>	pure(A value)
Tuple2<S,A>	run(S state)
static <S> State<S,Nothing>	set(S value)
static <S,A> State<S,A>	state(Function1<S,Tuple2<S,A>> runState)

Method Detail

run

Tuple2<S,A> run(S state)

map

default <R> State<S,R> map(Function1<A,R> mapper)

Specified by:

map in interface Mappable<Higher1<State.µ,S>,A>

flatMap

default <R> State<S,R> flatMap(Function1<A,? extends Higher2<State.µ,S,R>> mapper)

Specified by:

flatMap in interface FlatMap2<State.µ,S,A>

eval

default A eval(S state)

state

static <S,A> State<S,A> state(Function1<S,Tuple2<S,A>> runState)

pure

static <S,A> State<S,A> pure(A value)

get

static <S> State<S,S> get()

set

static <S> State<S,Nothing> set(S value)

modify

static <S> State<S,Nothing> modify(Operator1<S> mapper)

inspect

static <S,A> State<S,A> inspect(Function1<S,A> mapper)

compose

static <S,A> State<S,Sequence<A>> compose(Sequence<State<S,A>> states)

map2

static <S,A,B,C> State<S,C> map2(State<S,A> sa,
                                 State<S,B> sb,
                                 Function2<A,B,C> mapper)

narrowK

static <S,A> State<S,A> narrowK(Higher2<State.µ,S,A> hkt)

narrowK

static <S,A> State<S,A> narrowK(Higher1<Higher1<State.µ,S>,A> hkt)

monad

static <V> Monad<Higher1<State.µ,V>> monad()