Uses of Interface
com.github.tonivade.purefun.typeclasses.Monad

Packages that use Monad

Package	Description
com.github.tonivade.purefun.free
com.github.tonivade.purefun.instances
com.github.tonivade.purefun.transformer
com.github.tonivade.purefun.typeclasses

Uses of Monad in com.github.tonivade.purefun.free

Subinterfaces of Monad in com.github.tonivade.purefun.free

Modifier and Type	Interface	Description
(package private) interface	FreeMonad<F extends Kind<F,?>>

Methods in com.github.tonivade.purefun.free that return Monad

Modifier and Type	Method	Description
static <F extends Kind<F, ?>> Monad<Free<F,?>>	Free.monadF()

Methods in com.github.tonivade.purefun.free with parameters of type Monad

Modifier and Type	Method	Description
default <G extends Kind<G, ?>> Kind<G,A>	Free.foldMap(Monad<G> monad, FunctionK<F,G> interpreter)
private <G extends Kind<G, ?>> Kind<G,Either<Free<F,B>,B>>	Free.FlatMapped.foldStep(Monad<G> monad, FunctionK<F,G> interpreter)
private <G extends Kind<G, ?>> Kind<G,Either<Free<F,A>,A>>	Free.foldStep(Monad<G> monad, FunctionK<F,G> interpreter)

Uses of Monad in com.github.tonivade.purefun.instances

Subinterfaces of Monad in com.github.tonivade.purefun.instances

Modifier and Type	Interface	Description
(package private) interface	EIOAsync
(package private) interface	EIOBracket<E>
(package private) interface	EIOConcurrent
(package private) interface	EIOMonad<E>
(package private) interface	EIOMonadDefer
(package private) interface	EIOMonadError<E>
(package private) interface	EIOMonadThrow
(package private) interface	EitherMonad<L>
(package private) interface	EitherMonadError<L>
(package private) interface	EitherMonadThrow
(package private) interface	EitherTBracket<F extends Kind<F,?>,E>
(package private) interface	EitherTMonad<F extends Kind<F,?>,L>
(package private) interface	EitherTMonadDefer<F extends Kind<F,?>>
(package private) interface	EitherTMonadErrorFromMonad<F extends Kind<F,?>,E>
(package private) interface	EitherTMonadErrorFromMonadError<F extends Kind<F,?>,E>
(package private) interface	EitherTMonadThrowFromMonad<F extends Kind<F,?>>
(package private) interface	EitherTMonadThrowFromMonadThrow<F extends Kind<F,?>>
(package private) interface	EvalMonad
(package private) interface	EvalMonadError
(package private) interface	EvalMonadThrow
(package private) interface	Function1Monad<T>
(package private) interface	FutureMonad
(package private) interface	FutureMonadThrow
(package private) interface	IdMonad
(package private) interface	IOAsync
(package private) interface	IOBracket
(package private) interface	IOConcurrent
(package private) interface	IOMonad
(package private) interface	IOMonadDefer
(package private) interface	IOMonadError
(package private) interface	IOMonadThrow
(package private) interface	KleisliMonad<F extends Kind<F,?>,Z>
(package private) interface	KleisliMonadError<F extends Kind<F,?>,R,E>
(package private) interface	KleisliMonadReader<F extends Kind<F,?>,R>
(package private) interface	KleisliMonadState<F extends Kind<F,?>,R,S>
(package private) interface	OptionMonad
(package private) interface	OptionMonadError
(package private) interface	OptionTBracket<F extends Kind<F,?>>
(package private) interface	OptionTMonad<F extends Kind<F,?>>
(package private) interface	OptionTMonadDefer<F extends Kind<F,?>>
(package private) interface	OptionTMonadErrorFromMonad<F extends Kind<F,?>>
(package private) interface	OptionTMonadErrorFromMonadError<F extends Kind<F,?>,E>
(package private) interface	OptionTMonadThrow<F extends Kind<F,?>>
(package private) interface	ProducerMonad
(package private) interface	PromiseMonad
(package private) interface	PureIOAsync<R>
(package private) interface	PureIOBracket<R,E>
(package private) interface	PureIOConcurrent<R>
(package private) interface	PureIOMonad<R,E>
(package private) interface	PureIOMonadDefer<R>
(package private) interface	PureIOMonadError<R,E>
(package private) interface	PureIOMonadThrow<R>
(package private) interface	PureStreamMonad<F extends Kind<F,?>>
(package private) interface	ReaderMonad<R>
(package private) interface	ReaderMonadReader<R>
(package private) interface	RIOAsync<R>
(package private) interface	RIOBracket<R>
(package private) interface	RIOConcurrent<R>
(package private) interface	RIOMonad<R>
(package private) interface	RIOMonadDefer<R>
(package private) interface	RIOMonadError<R>
(package private) interface	RIOMonadThrow<R>
(package private) interface	SequenceMonad
(package private) interface	StateMonad<S>
(package private) interface	StateMonadState<S>
(package private) interface	StateTMonad<F extends Kind<F,?>,S>
(package private) interface	StateTMonadError<F extends Kind<F,?>,S,E>
(package private) interface	StateTMonadReader<F extends Kind<F,?>,S,R>
(package private) interface	StateTMonadState<F extends Kind<F,?>,S>
(package private) interface	TaskAsync
(package private) interface	TaskBracket
(package private) interface	TaskConcurrent
(package private) interface	TaskMonad
(package private) interface	TaskMonadDefer
(package private) interface	TaskMonadError
(package private) interface	TaskMonadThrow
(package private) interface	TrampolineMonad
(package private) interface	TryMonad
(package private) interface	TryMonadError
(package private) interface	TryMonadThrow
(package private) interface	UIOAsync
(package private) interface	UIOBracket
(package private) interface	UIOConcurrent
(package private) interface	UIOMonad
(package private) interface	UIOMonadDefer
(package private) interface	UIOMonadError
(package private) interface	UIOMonadThrow
(package private) interface	URIOAsync<R>
(package private) interface	URIOBracket<R>
(package private) interface	URIOConcurrent<R>
(package private) interface	URIOMonad<R>
(package private) interface	URIOMonadDefer<R>
(package private) interface	URIOMonadError<R>
(package private) interface	URIOMonadThrow<R>
(package private) interface	ValidationMonad<E>
(package private) interface	ValidationMonadError<E>
(package private) interface	ValidationMonadThrow
(package private) interface	WriterMonad<L>
(package private) interface	WriterTMonad<F extends Kind<F,?>,L>
(package private) interface	WriterTMonadError<F extends Kind<F,?>,L,E>
(package private) interface	WriterTMonadWriter<F extends Kind<F,?>,L>

Classes in com.github.tonivade.purefun.instances that implement Monad

Modifier and Type	Class	Description
(package private) class	EffectEMonadError<F extends Kind<F,?>,E>
(package private) class	EffectRMonad<F extends Kind<F,?>,R,E>
(package private) class	EffectRMonadError<F extends Kind<F,?>,R,E>
(package private) class	EffectRMonadReader<F extends Kind<F,?>,R,E>
class	MonadMTL<F extends Kind<F,?>,S,R,E>

Fields in com.github.tonivade.purefun.instances declared as Monad

Modifier and Type	Field	Description
private final Monad<Kleisli<MonadMTL.EffectE<F,E,?>,R,?>>	EffectRMonad.monad
private final Monad<F>	MonadMTL.monad
private final Monad<MonadMTL.EffectR<F,R,E,?>>	MonadMTL.monadR

Methods in com.github.tonivade.purefun.instances that return Monad

Modifier and Type	Method	Description
static <F extends Kind<F, ?>, L> Monad<WriterT<F,L,?>>	WriterTMonad.instance(Monoid<L> monoid, Monad<F> monadF)
static <E> Monad<EIO<E,?>>	EIOInstances.monad()
static <L> Monad<Either<L,?>>	EitherInstances.monad()
static <F extends Kind<F, ?>, L> Monad<EitherT<F,L,?>>	EitherTInstances.monad(Monad<F> monadF)
static Monad<Eval<?>>	EvalInstances.monad()
static <T> Monad<Function1<T,?>>	Function1Instances.monad()
static Monad<Future<?>>	FutureInstances.monad()
static Monad<Future<?>>	FutureInstances.monad(Executor executor)
static Monad<Id<?>>	IdInstances.monad()
static Monad<IO<?>>	IOInstances.monad()
static <F extends Kind<F, ?>, Z> Monad<Kleisli<F,Z,?>>	KleisliInstances.monad(Monad<F> monadF)
static Monad<Option<?>>	OptionInstances.monad()
static <F extends Kind<F, ?>> Monad<OptionT<F,?>>	OptionTInstances.monad(Monad<F> monadF)
static Monad<Producer<?>>	ProducerInstances.monad()
static Monad<Promise<?>>	PromiseInstances.monad()
static Monad<Promise<?>>	PromiseInstances.monad(Executor executor)
static <R, E> Monad<PureIO<R,E,?>>	PureIOInstances.monad()
static <F extends Kind<F, ?>> Monad<PureStream<F,?>>	PureStreamInstances.monad(PureStream.Of<F> streamOf)
static <R> Monad<Reader<R,?>>	ReaderInstances.monad()
static <R> Monad<RIO<R,?>>	RIOInstances.monad()
static Monad<Sequence<?>>	SequenceInstances.monad()
static <S> Monad<State<S,?>>	StateInstances.monad()
static <F extends Kind<F, ?>, S> Monad<StateT<F,S,?>>	StateTInstances.monad(Monad<F> monadF)
static Monad<Task<?>>	TaskInstances.monad()
static Monad<Trampoline<?>>	TrampolineInstances.monad()
static Monad<Try<?>>	TryInstances.monad()
static Monad<UIO<?>>	UIOInstances.monad()
static <R> Monad<URIO<R,?>>	URIOInstances.monad()
static <E> Monad<Validation<E,?>>	ValidationInstances.monad()
static <L> Monad<Writer<L,?>>	WriterInstances.monad(Monoid<L> monoid)
static <F extends Kind<F, ?>, L> Monad<WriterT<F,L,?>>	WriterTInstances.monad(Monoid<L> monoid, Monad<F> monadF)
Monad<F>	EitherTMonad.monadF()
Monad<F>	KleisliMonad.monadF()
Monad<F>	OptionTMonad.monadF()
Monad<F>	StateTMonad.monadF()
Monad<F>	WriterTMonad.monadF()

Methods in com.github.tonivade.purefun.instances with parameters of type Monad

Modifier and Type	Method	Description
static <F extends Kind<F, ?>, L> EitherTMonad<F,L>	EitherTMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>, L> EitherTMonadErrorFromMonad<F,L>	EitherTMonadErrorFromMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>> EitherTMonadThrowFromMonad<F>	EitherTMonadThrowFromMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>, Z> KleisliMonad<F,Z>	KleisliMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>, Z> KleisliMonadReader<F,Z>	KleisliMonadReader.instance(Monad<F> monadF)
static <F extends Kind<F, ?>> OptionTMonad<F>	OptionTMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>> OptionTMonadErrorFromMonad<F>	OptionTMonadErrorFromMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>, S> StateTMonad<F,S>	StateTMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>, S> StateTMonadState<F,S>	StateTMonadState.instance(Monad<F> monadF)
static <F extends Kind<F, ?>, L> Monad<WriterT<F,L,?>>	WriterTMonad.instance(Monoid<L> monoid, Monad<F> monadF)
static <F extends Kind<F, ?>, L> MonadWriter<WriterT<F,L,?>,L>	WriterTMonadWriter.instance(Monoid<L> monoid, Monad<F> monadF)
static <F extends Kind<F, ?>, L> Monad<EitherT<F,L,?>>	EitherTInstances.monad(Monad<F> monadF)
static <F extends Kind<F, ?>, Z> Monad<Kleisli<F,Z,?>>	KleisliInstances.monad(Monad<F> monadF)
static <F extends Kind<F, ?>> Monad<OptionT<F,?>>	OptionTInstances.monad(Monad<F> monadF)
static <F extends Kind<F, ?>, S> Monad<StateT<F,S,?>>	StateTInstances.monad(Monad<F> monadF)
static <F extends Kind<F, ?>, L> Monad<WriterT<F,L,?>>	WriterTInstances.monad(Monoid<L> monoid, Monad<F> monadF)
static <F extends Kind<F, ?>, L> MonadError<EitherT<F,L,?>,L>	EitherTInstances.monadError(Monad<F> monadF)
static <F extends Kind<F, ?>> MonadError<OptionT<F,?>,Unit>	OptionTInstances.monadError(Monad<F> monadF)
static <F extends Kind<F, ?>, Z> MonadReader<Kleisli<F,Z,?>,Z>	KleisliInstances.monadReader(Monad<F> monadF)
static <F extends Kind<F, ?>, S> MonadState<StateT<F,S,?>,S>	StateTInstances.monadState(Monad<F> monadF)
static <F extends Kind<F, ?>> MonadThrow<EitherT<F,Throwable,?>>	EitherTInstances.monadThrow(Monad<F> monadF)
static <F extends Kind<F, ?>, L> MonadWriter<WriterT<F,L,?>,L>	WriterTInstances.monadWriter(Monoid<L> monoid, Monad<F> monadF)

Constructors in com.github.tonivade.purefun.instances with parameters of type Monad

Modifier	Constructor	Description
	EffectEMonadError(Monad<F> monad)
	EffectRMonad(Monad<F> monad)
	EffectRMonadError(Monad<F> monad)
	EffectRMonadReader(Monad<F> monad)
	MonadMTL(Monad<F> monad)

Uses of Monad in com.github.tonivade.purefun.transformer

Methods in com.github.tonivade.purefun.transformer that return Monad

Modifier and Type	Method	Description
Monad<F>	EitherT.monad()
Monad<F>	Kleisli.monad()
Monad<F>	OptionT.monad()
Monad<F>	StateT.monad()
Monad<F>	WriterT.monad()

Methods in com.github.tonivade.purefun.transformer with parameters of type Monad

Modifier and Type	Method	Description
static <F extends Kind<F, ?>, Z> Kleisli<F,Z,Z>	Kleisli.env(Monad<F> monad)
static <F extends Kind<F, ?>, R> EitherT<F,Throwable,R>	EitherT.fromOption(Monad<F> monad, Option<R> value)
static <F extends Kind<F, ?>, R> EitherT<F,Throwable,R>	EitherT.fromTry(Monad<F> monad, Try<R> value)
static <F extends Kind<F, ?>, S> StateT<F,S,S>	StateT.get(Monad<F> monad)
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateT.inspect(Monad<F> monad, Function1<S,A> mapper)
static <F extends Kind<F, ?>, L, R> EitherT<F,L,R>	EitherT.left(Monad<F> monad, L left)
static <F extends Kind<F, ?>, L, R> EitherT<F,L,R>	EitherT.lift(Monad<F> monad, Either<L,R> either)
static <F extends Kind<F, ?>, A, B> Kleisli<F,A,B>	Kleisli.lift(Monad<F> monad, Function1<? super A,? extends B> map)
static <F extends Kind<F, ?>, T> OptionT<F,T>	OptionT.lift(Monad<F> monad, Option<T> value)
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateT.lift(Monad<F> monad, Function1<S,Tuple2<S,A>> run)
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateT.lift(Monad<F> monad, Kind<F,A> value)
static <F extends Kind<F, ?>, L, A> WriterT<F,L,A>	WriterT.lift(Monoid<L> monoid, Monad<F> monad, Tuple2<L,A> value)
default <G extends Kind<G, ?>> EitherT<G,L,R>	EitherT.mapK(Monad<G> other, FunctionK<F,G> functionK)
default <G extends Kind<G, ?>> OptionT<G,T>	OptionT.mapK(Monad<G> other, FunctionK<F,G> functionK)
default <G extends Kind<G, ?>> StateT<G,S,A>	StateT.mapK(Monad<G> other, FunctionK<F,G> functionK)
default <G extends Kind<G, ?>> WriterT<G,L,A>	WriterT.mapK(Monad<G> monadG, FunctionK<F,G> functionK)
static <F extends Kind<F, ?>, S> StateT<F,S,Unit>	StateT.modify(Monad<F> monad, Operator1<S> mapper)
static <F extends Kind<F, ?>, T> OptionT<F,T>	OptionT.none(Monad<F> monad)
static <F extends Kind<F, ?>, L, R> EitherT<F,L,R>	EitherT.of(Monad<F> monad, Kind<F,Either<L,R>> value)
static <F extends Kind<F, ?>, A, B> Kleisli<F,A,B>	Kleisli.of(Monad<F> monad, Function1<? super A,? extends Kind<F,? extends B>> run)
static <F extends Kind<F, ?>, T> OptionT<F,T>	OptionT.of(Monad<F> monad, Kind<F,Option<T>> value)
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateT.of(Monad<F> monad, Function1<S,Kind<F,Tuple2<S,A>>> run)
static <F extends Kind<F, ?>, A, B> Kleisli<F,A,B>	Kleisli.pure(Monad<F> monad, B value)
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateT.pure(Monad<F> monad, A value)
static <F extends Kind<F, ?>, L, A> WriterT<F,L,A>	WriterT.pure(Monoid<L> monoid, Monad<F> monad, A value)
static <F extends Kind<F, ?>, L, R> EitherT<F,L,R>	EitherT.right(Monad<F> monad, R right)
static <F extends Kind<F, ?>, S> StateT<F,S,Unit>	StateT.set(Monad<F> monad, S value)
static <F extends Kind<F, ?>, T> OptionT<F,T>	OptionT.some(Monad<F> monad, T value)
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateT.state(Monad<F> monad, Function1<S,Kind<F,Tuple2<S,A>>> run)
static <F extends Kind<F, ?>, S, A> StateT<F,S,Sequence<A>>	StateT.traverse(Monad<F> monad, Sequence<StateT<F,S,A>> states)
static <F extends Kind<F, ?>, L, A> WriterT<F,L,A>	WriterT.writer(Monoid<L> monoid, Monad<F> monad, Kind<F,Tuple2<L,A>> value)

Uses of Monad in com.github.tonivade.purefun.typeclasses

Subinterfaces of Monad in com.github.tonivade.purefun.typeclasses

Modifier and Type	Interface	Description
interface	Async<F extends Kind<F,?>>
interface	Bracket<F extends Kind<F,?>,E>
interface	Concurrent<F extends Kind<F,?>>
interface	MonadDefer<F extends Kind<F,?>>
interface	MonadError<F extends Kind<F,?>,E>
interface	MonadReader<F extends Kind<F,?>,R>
interface	MonadState<F extends Kind<F,?>,S>
interface	MonadThrow<F extends Kind<F,?>>
interface	MonadWriter<F extends Kind<F,?>,W>

Classes in com.github.tonivade.purefun.typeclasses that implement Monad

Modifier and Type	Class	Description
(package private) final class	ReferenceMonadState<F extends Kind<F,?>,S>

Fields in com.github.tonivade.purefun.typeclasses declared as Monad

Modifier and Type	Field	Description
protected final Monad<F>	AbstractFlatMap.monad
private final Monad<F>	For.FlatMap.monad	The field for the monad record component.
private final Monad<F>	ReferenceMonadState.monad

Methods in com.github.tonivade.purefun.typeclasses that return Monad

Modifier and Type	Method	Description
Monad<F>	For.FlatMap.monad()	Returns the value of the monad record component.
Monad<F>	Instance.monad(Object... params)
static <F extends Kind<F, ?>> Monad<F>	Instances.monad(F... reified)
static <F extends Kind<F, ?>> Monad<F>	Instances.monad(Class<F> type, Object... params)
Monad<F>	Parallel.monad()

Methods in com.github.tonivade.purefun.typeclasses with parameters of type Monad

Modifier and Type	Method	Description
default <G extends Kind<G, ?>, A, B> Kind<G,B>	Foldable.foldM(Monad<G> monad, Kind<F,? extends A> value, B initial, Function2<? super B,? super A,? extends Kind<G,? extends B>> mapper)
static <F extends Kind<F, ?>> Parallel<F,F>	Parallel.identity(Monad<F> monad)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Parallel<F,G>	Parallel.of(Monad<F> monad, Applicative<G> applicative, FunctionK<F,G> to, FunctionK<G,F> from)
static <F extends Kind<F, ?>> For.FlatMap<F>	For.with(Monad<F> monad)
static <F extends Kind<F, ?>, T> FlatMap1<F,T>	For.with(Monad<F> monad, Kind<F,? extends T> value1)

Constructors in com.github.tonivade.purefun.typeclasses with parameters of type Monad

Modifier	Constructor	Description
protected	AbstractFlatMap(Monad<F> monad, Function1<? super A,? extends Kind<F,? extends B>> value)
	FlatMap(Monad<F> monad)	Creates an instance of a FlatMap record class.
(package private)	FlatMap1(Monad<F> monad, Producer<Kind<F,? extends A>> value)
(package private)	FlatMap2(Monad<F> monad, Producer<? extends Kind<F,? extends A>> value1, Function1<? super A,? extends Kind<F,? extends B>> value2)
(package private)	FlatMap3(Monad<F> monad, Producer<? extends Kind<F,? extends A>> value1, Function1<? super A,? extends Kind<F,? extends B>> value2, Function1<? super B,? extends Kind<F,? extends C>> value3)
(package private)	FlatMap4(Monad<F> monad, Producer<? extends Kind<F,? extends A>> value1, Function1<? super A,? extends Kind<F,? extends B>> value2, Function1<? super B,? extends Kind<F,? extends C>> value3, Function1<? super C,? extends Kind<F,? extends D>> value4)
(package private)	FlatMap5(Monad<F> monad, Producer<? extends Kind<F,? extends A>> value1, Function1<? super A,? extends Kind<F,? extends B>> value2, Function1<? super B,? extends Kind<F,? extends C>> value3, Function1<? super C,? extends Kind<F,? extends D>> value4, Function1<? super D,? extends Kind<F,? extends E>> value5)
(package private)	ReferenceMonadState(Reference<F,S> ref, Monad<F> monad)