Uses of Interface
com.github.tonivade.purefun.Kind

Packages that use Kind

Package	Description
com.github.tonivade.purefun
com.github.tonivade.purefun.concurrent
com.github.tonivade.purefun.core
com.github.tonivade.purefun.data
com.github.tonivade.purefun.effect
com.github.tonivade.purefun.free
com.github.tonivade.purefun.instances
com.github.tonivade.purefun.monad
com.github.tonivade.purefun.stream
com.github.tonivade.purefun.transformer
com.github.tonivade.purefun.type
com.github.tonivade.purefun.typeclasses

Uses of Kind in com.github.tonivade.purefun

Classes in com.github.tonivade.purefun with type parameters of type Kind

Modifier and Type	Interface	Description
interface	Kind<F extends Kind<F,?>,A>

Methods in com.github.tonivade.purefun with type parameters of type Kind

Modifier and Type	Method	Description
default <R extends Kind<F, ?>> R	Kind.fix(Function<? super Kind<F,? extends A>,? extends R> fixer)
static <F extends Kind<F, ?>, A> Kind<F,A>	Kind.narrowK(Kind<F,? extends A> kind)

Methods in com.github.tonivade.purefun that return Kind

Modifier and Type	Method	Description
default Kind<F,A>	Kind.kind()
static <F extends Kind<F, ?>, A> Kind<F,A>	Kind.narrowK(Kind<F,? extends A> kind)

Methods in com.github.tonivade.purefun with parameters of type Kind

Modifier and Type	Method	Description
static <F extends Kind<F, ?>, A> Kind<F,A>	Kind.narrowK(Kind<F,? extends A> kind)

Method parameters in com.github.tonivade.purefun with type arguments of type Kind

Modifier and Type	Method	Description
default <R extends Kind<F, ?>> R	Kind.fix(Function<? super Kind<F,? extends A>,? extends R> fixer)

Uses of Kind in com.github.tonivade.purefun.concurrent

Subinterfaces of Kind in com.github.tonivade.purefun.concurrent

Modifier and Type	Interface	Description
interface	Future<T>	This type is an abstraction of a computation executed in another thread.
interface	FutureOf<T>
interface	Promise<T>
interface	PromiseOf<T>

Classes in com.github.tonivade.purefun.concurrent that implement Kind

Modifier and Type	Class	Description
(package private) final class	FutureImpl<T>
(package private) final class	PromiseImpl<T>

Methods in com.github.tonivade.purefun.concurrent with parameters of type Kind

Modifier and Type	Method	Description
default <R> Promise<R>	Promise.andThen(Kind<Promise<?>,? extends R> next)
<R> Promise<R>	Promise.ap(Kind<Promise<?>,? extends Function1<? super T,? extends R>> apply)
<R> Promise<R>	PromiseImpl.ap(Kind<Promise<?>,? extends Function1<? super T,? extends R>> apply)
static <T> Future<T>	FutureOf.toFuture(Kind<Future<?>,? extends T> value)
static <T> Promise<T>	PromiseOf.toPromise(Kind<Promise<?>,? extends T> value)

Method parameters in com.github.tonivade.purefun.concurrent with type arguments of type Kind

Modifier and Type	Method	Description
private <R> Future<R>	FutureImpl.chain(Function1<? super Try<? extends T>,? extends Kind<Future<?>,? extends R>> mapper)
<R> Future<R>	Future.flatMap(Function1<? super T,? extends Kind<Future<?>,? extends R>> mapper)
<R> Future<R>	FutureImpl.flatMap(Function1<? super T,? extends Kind<Future<?>,? extends R>> mapper)
<R> Promise<R>	Promise.flatMap(Function1<? super T,? extends Kind<Promise<?>,? extends R>> mapper)
<R> Promise<R>	PromiseImpl.flatMap(Function1<? super T,? extends Kind<Promise<?>,? extends R>> mapper)

Uses of Kind in com.github.tonivade.purefun.core

Subinterfaces of Kind in com.github.tonivade.purefun.core

Modifier and Type	Interface	Description
interface	Applicable<F extends Applicable<F,?>,A>
interface	Bindable<F extends Bindable<F,?>,A>
interface	Effect<F extends Effect<F,?>,A>
interface	Function1<A,R>	This interface represents a function with a single parameter.
interface	Function1Of<A,R>
interface	Mappable<F extends Mappable<F,?>,A>
interface	Operator1<T>
interface	Producer<T>	This interface represents a function without any parameter.
interface	ProducerOf<T>
interface	Trampoline<T>
interface	TrampolineOf<T>
interface	Tuple1Of<A>
interface	Tuple2Of<A,B>

Classes in com.github.tonivade.purefun.core that implement Kind

Modifier and Type	Class	Description
(package private) final class	MemoizedFunction<T,R>
(package private) final class	MemoizedProducer<T>
static final record	Trampoline.Done<T>
static final record	Trampoline.More<T>
final class	Tuple1<A>
final class	Tuple2<A,B>

Methods in com.github.tonivade.purefun.core with parameters of type Kind

Modifier and Type	Method	Description
default <R> Bindable<F,R>	Bindable.andThen(Kind<F,? extends R> next)
default <R> Effect<F,R>	Effect.andThen(Kind<F,? extends R> next)
<R> Applicable<F,R>	Applicable.ap(Kind<F,? extends Function1<? super A,? extends R>> apply)
<R> Effect<F,R>	Effect.ap(Kind<F,? extends Function1<? super A,? extends R>> apply)
static <F extends Applicable<F, ?>, A> Applicable<F,A>	Applicable.narrowK(Kind<F,? extends A> kind)
static <F extends Bindable<F, ?>, A> Bindable<F,A>	Bindable.narrowK(Kind<F,? extends A> kind)
static <F extends Effect<F, ?>, A> Effect<F,A>	Effect.narrowK(Kind<F,? extends A> kind)
static <F extends Mappable<F, ?>, A> Mappable<F,A>	Mappable.narrowK(Kind<F,? extends A> kind)
static <A, R> Function1<A,R>	Function1Of.toFunction1(Kind<Function1<A,?>,? extends R> value)
static <T> Producer<T>	ProducerOf.toProducer(Kind<Producer<?>,? extends T> value)
static <T> Trampoline<T>	TrampolineOf.toTrampoline(Kind<Trampoline<?>,? extends T> value)
static <A> Tuple1<A>	Tuple1Of.toTuple1(Kind<Tuple1<?>,? extends A> value)
static <A, B> Tuple2<A,B>	Tuple2Of.toTuple2(Kind<Tuple2<A,?>,? extends B> value)
default <B> Applicable<F,Tuple2<A,B>>	Applicable.zip(Kind<F,? extends B> other)
default <B> Effect<F,Tuple2<A,B>>	Effect.zip(Kind<F,? extends B> other)
default <B> Applicable<F,A>	Applicable.zipLeft(Kind<F,? extends B> other)
default <B> Effect<F,A>	Effect.zipLeft(Kind<F,? extends B> other)
default <B> Applicable<F,B>	Applicable.zipRight(Kind<F,? extends B> other)
default <B> Effect<F,B>	Effect.zipRight(Kind<F,? extends B> other)
default <B, R> Applicable<F,R>	Applicable.zipWith(Kind<F,? extends B> other, Function2<? super A,? super B,? extends R> mapper)
default <B, C> Effect<F,C>	Effect.zipWith(Kind<F,? extends B> other, Function2<? super A,? super B,? extends C> mapper)

Method parameters in com.github.tonivade.purefun.core with type arguments of type Kind

Modifier and Type	Method	Description
<R> Bindable<F,R>	Bindable.flatMap(Function1<? super A,? extends Kind<F,? extends R>> mapper)
<R> Effect<F,R>	Effect.flatMap(Function1<? super A,? extends Kind<F,? extends R>> mapper)
default <R> Trampoline<R>	Trampoline.flatMap(Function1<? super T,? extends Kind<Trampoline<?>,? extends R>> map)

Uses of Kind in com.github.tonivade.purefun.data

Subinterfaces of Kind in com.github.tonivade.purefun.data

Modifier and Type	Interface	Description
interface	ImmutableArray<E>	Similar to a ArrayList
interface	ImmutableList<E>	Similar to a LinkedList
interface	ImmutableSet<E>	Similar to a HashSet
interface	ImmutableTree<E>	Similar to a TreeSet
interface	Sequence<E>
interface	SequenceOf<E>

Classes in com.github.tonivade.purefun.data that implement Kind

Modifier and Type	Class	Description
static final class	ImmutableArray.PImmutableArray<E>
static final class	ImmutableList.PImmutableList<E>
static final class	ImmutableSet.PImmutableSet<E>
static final class	ImmutableTree.PImmutableTree<E>
final class	NonEmptyList<E>

Methods in com.github.tonivade.purefun.data with parameters of type Kind

Modifier and Type	Method	Description
static <E> Sequence<E>	SequenceOf.toSequence(Kind<Sequence<?>,? extends E> value)

Method parameters in com.github.tonivade.purefun.data with type arguments of type Kind

Modifier and Type	Method	Description
default <R> ImmutableArray<R>	ImmutableArray.flatMap(Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)
default <R> ImmutableList<R>	ImmutableList.flatMap(Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)
default <R> ImmutableSet<R>	ImmutableSet.flatMap(Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)
default <R> ImmutableTree<R>	ImmutableTree.flatMap(Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)
default <R> ImmutableTree<R>	ImmutableTree.flatMap(Comparator<? super R> comparator, Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)
<R> NonEmptyList<R>	NonEmptyList.flatMap(Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)
<R> Sequence<R>	Sequence.flatMap(Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)

Uses of Kind in com.github.tonivade.purefun.effect

Subinterfaces of Kind in com.github.tonivade.purefun.effect

Modifier and Type	Interface	Description
interface	EIOOf<E,A>
interface	ManagedOf<R,E,A>
interface	PureIO<R,E,A>
interface	PureIOOf<R,E,A>
interface	RIOOf<R,A>
interface	TaskOf<A>
interface	UIOOf<A>
interface	URIOOf<R,A>

Classes in com.github.tonivade.purefun.effect that implement Kind

Modifier and Type	Class	Description
final class	EIO<E,A>
final class	Managed<R,E,A>
static final class	PureIO.AccessM<R,E,A>
static final class	PureIO.Async<R,E,A>
static final class	PureIO.Attempt<R,E,A>
static final class	PureIO.Delay<R,E,A>
static final class	PureIO.Failure<R,E,A>
static final class	PureIO.FlatMapped<R,E,A,F,B>
static final class	PureIO.Pure<R,E,A>
static final class	PureIO.Recover<R,E,A>
static final class	PureIO.Suspend<R,E,A>
static final class	PureIO.Throw<R,E,A>
final class	RIO<R,A>
final class	Task<A>
final class	UIO<A>
final class	URIO<R,A>

Fields in com.github.tonivade.purefun.effect declared as Kind

Modifier and Type	Field	Description
private final Kind<PureIO<R,E,?>,A>	PureIO.FlatMapped.current

Fields in com.github.tonivade.purefun.effect with type parameters of type Kind

Modifier and Type	Field	Description
private final Function1<? super R,? extends Kind<PureIO<R,E,?>,? extends A>>	PureIO.AccessM.function
private final Producer<Kind<PureIO<R,E,?>,? extends A>>	PureIO.Suspend.lazy
private final Function1<? super A,? extends Kind<PureIO<R,F,?>,? extends B>>	PureIO.FlatMapped.next
private final Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends B>>	PureIO.FlatMapped.nextError
private final Deque<PartialFunction1<? super Throwable,? extends Kind<PureIO<R,E,?>,? extends A>>>	StackItem.recover

Methods in com.github.tonivade.purefun.effect that return Kind

Modifier and Type	Method	Description
static <R, E, A> Kind<PureIO<R,E,?>,A>	PureIO.accessM(R env, PureIO.AccessM<R,E,A> accessM)
private static <R, E, F, A, B> Kind<PureIO<R,E,?>,A>	PureIO.unwrap(R env, Kind<PureIO<R,E,?>,A> current, CallStack<R,F,B> stack, Function1<Kind<PureIO<R,E,?>,? extends A>,Kind<PureIO<R,F,?>,? extends B>> next)

Methods in com.github.tonivade.purefun.effect with parameters of type Kind

Modifier and Type	Method	Description
static <R, E, A> PureIO<R,E,A>	PureIO.absorb(Kind<PureIO<R,E,?>,Either<E,A>> value)
<B> EIO<E,B>	EIO.andThen(Kind<EIO<E,?>,? extends B> next)
<B> Managed<R,E,B>	Managed.andThen(Kind<Managed<A,E,?>,B> other)
default <B> PureIO<R,E,B>	PureIO.andThen(Kind<PureIO<R,E,?>,? extends B> next)
<B> RIO<R,B>	RIO.andThen(Kind<RIO<R,?>,? extends B> next)
<B> Task<B>	Task.andThen(Kind<Task<?>,? extends B> next)
<B> UIO<B>	UIO.andThen(Kind<UIO<?>,? extends B> next)
<B> URIO<R,B>	URIO.andThen(Kind<URIO<R,?>,? extends B> next)
<B> EIO<E,B>	EIO.ap(Kind<EIO<E,?>,? extends Function1<? super A,? extends B>> apply)
default <B> PureIO<R,E,B>	PureIO.ap(Kind<PureIO<R,E,?>,? extends Function1<? super A,? extends B>> apply)
<B> RIO<R,B>	RIO.ap(Kind<RIO<R,?>,? extends Function1<? super A,? extends B>> apply)
<B> Task<B>	Task.ap(Kind<Task<?>,? extends Function1<? super A,? extends B>> apply)
<B> UIO<B>	UIO.ap(Kind<UIO<?>,? extends Function1<? super A,? extends B>> apply)
<B> URIO<R,B>	URIO.ap(Kind<URIO<R,?>,? extends Function1<? super A,? extends B>> apply)
static <E, A extends AutoCloseable, B> EIO<E,B>	EIO.bracket(Kind<EIO<E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> use)
static <E, A, B> EIO<E,B>	EIO.bracket(Kind<EIO<E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> use, Consumer1<? super A> release)
static <E, A, B> EIO<E,B>	EIO.bracket(Kind<EIO<E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> use, Function1<? super A,? extends Kind<EIO<E,?>,Unit>> release)
static <R, E, A extends AutoCloseable, B> PureIO<R,E,B>	PureIO.bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use)
static <R, E, A, B> PureIO<R,E,B>	PureIO.bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use, Consumer1<? super A> release)
static <R, E, A, B> PureIO<R,E,B>	PureIO.bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use, Function1<? super A,? extends Kind<PureIO<R,E,?>,Unit>> release)
static <R, A extends AutoCloseable, B> RIO<R,B>	RIO.bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use)
static <R, A, B> RIO<R,B>	RIO.bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use, Consumer1<? super A> release)
static <R, A, B> RIO<R,B>	RIO.bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use, Function1<? super A,? extends Kind<RIO<R,?>,Unit>> release)
static <A extends AutoCloseable, B> Task<B>	Task.bracket(Kind<Task<?>,? extends A> acquire, Function1<? super A,? extends Kind<Task<?>,? extends B>> use)
static <A, B> Task<B>	Task.bracket(Kind<Task<?>,? extends A> acquire, Function1<? super A,? extends Kind<Task<?>,? extends B>> use, Consumer1<? super A> release)
static <A, B> Task<B>	Task.bracket(Kind<Task<?>,? extends A> acquire, Function1<? super A,? extends Kind<Task<?>,? extends B>> use, Function1<? super A,? extends Kind<Task<?>,Unit>> release)
static <A extends AutoCloseable, B> UIO<B>	UIO.bracket(Kind<UIO<?>,? extends A> acquire, Function1<? super A,? extends Kind<UIO<?>,? extends B>> use)
static <A, B> UIO<B>	UIO.bracket(Kind<UIO<?>,? extends A> acquire, Function1<? super A,? extends Kind<UIO<?>,? extends B>> use, Consumer1<? super A> release)
static <A, B> UIO<B>	UIO.bracket(Kind<UIO<?>,? extends A> acquire, Function1<? super A,? extends Kind<UIO<?>,? extends B>> use, Function1<? super A,? extends Kind<UIO<?>,Unit>> release)
static <R, A extends AutoCloseable, B> URIO<R,B>	URIO.bracket(Kind<URIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> use)
static <R, A, B> URIO<R,B>	URIO.bracket(Kind<URIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> use, Consumer1<? super A> release)
static <R, A, B> URIO<R,B>	URIO.bracket(Kind<URIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> use, Function1<? super A,? extends Kind<URIO<R,?>,Unit>> release)
default PureIO<R,E,A>	PureIO.orElse(Kind<PureIO<R,E,?>,? extends A> other)
RIO<R,A>	RIO.orElse(Kind<RIO<R,?>,? extends A> other)
Task<A>	Task.orElse(Kind<Task<?>,? extends A> other)
static <E, A, B, C> EIO<E,C>	EIO.parMap2(Kind<EIO<E,?>,? extends A> za, Kind<EIO<E,?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <E, A, B, C> EIO<E,C>	EIO.parMap2(Executor executor, Kind<EIO<E,?>,? extends A> za, Kind<EIO<E,?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <R, E, A, B, C> PureIO<R,E,C>	PureIO.parMap2(Kind<PureIO<R,E,?>,? extends A> za, Kind<PureIO<R,E,?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <R, E, A, B, C> PureIO<R,E,C>	PureIO.parMap2(Executor executor, Kind<PureIO<R,E,?>,? extends A> za, Kind<PureIO<R,E,?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <R, A, B, C> RIO<R,C>	RIO.parMap2(Kind<RIO<R,?>,? extends A> za, Kind<RIO<R,?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <R, A, B, C> RIO<R,C>	RIO.parMap2(Executor executor, Kind<RIO<R,?>,? extends A> za, Kind<RIO<R,?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <A, B, C> Task<C>	Task.parMap2(Kind<Task<?>,? extends A> za, Kind<Task<?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <A, B, C> Task<C>	Task.parMap2(Executor executor, Kind<Task<?>,? extends A> za, Kind<Task<?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <A, B, C> UIO<C>	UIO.parMap2(Kind<UIO<?>,? extends A> za, Kind<UIO<?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <A, B, C> UIO<C>	UIO.parMap2(Executor executor, Kind<UIO<?>,? extends A> za, Kind<UIO<?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <R, A, B, C> URIO<R,C>	URIO.parMap2(Kind<URIO<R,?>,? extends A> za, Kind<URIO<R,?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <R, A, B, C> URIO<R,C>	URIO.parMap2(Executor executor, Kind<URIO<R,?>,? extends A> za, Kind<URIO<R,?>,? extends B> zb, Function2<? super A,? super B,? extends C> mapper)
static <E, A, B> EIO<E,Either<A,B>>	EIO.race(Kind<EIO<E,?>,? extends A> fa, Kind<EIO<E,?>,? extends B> fb)
static <E, A, B> EIO<E,Either<A,B>>	EIO.race(Executor executor, Kind<EIO<E,?>,? extends A> fa, Kind<EIO<E,?>,? extends B> fb)
static <R, E, A, B> PureIO<R,E,Either<A,B>>	PureIO.race(Kind<PureIO<R,E,?>,? extends A> fa, Kind<PureIO<R,E,?>,? extends B> fb)
static <R, E, A, B> PureIO<R,E,Either<A,B>>	PureIO.race(Executor executor, Kind<PureIO<R,E,?>,? extends A> fa, Kind<PureIO<R,E,?>,? extends B> fb)
static <R, A, B> RIO<R,Either<A,B>>	RIO.race(Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
static <R, A, B> RIO<R,Either<A,B>>	RIO.race(Executor executor, Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
static <A, B> Task<Either<A,B>>	Task.race(Kind<Task<?>,? extends A> fa, Kind<Task<?>,? extends B> fb)
static <A, B> Task<Either<A,B>>	Task.race(Executor executor, Kind<Task<?>,? extends A> fa, Kind<Task<?>,? extends B> fb)
static <A, B> UIO<Either<A,B>>	UIO.race(Kind<UIO<?>,? extends A> fa, Kind<UIO<?>,? extends B> fb)
static <A, B> UIO<Either<A,B>>	UIO.race(Executor executor, Kind<UIO<?>,? extends A> fa, Kind<UIO<?>,? extends B> fb)
static <R, A, B> URIO<R,Either<A,B>>	URIO.race(Kind<URIO<R,?>,? extends A> fa, Kind<URIO<R,?>,? extends B> fb)
static <R, A, B> URIO<R,Either<A,B>>	URIO.race(Executor executor, Kind<URIO<R,?>,? extends A> fa, Kind<URIO<R,?>,? extends B> fb)
static <E, A, B> EIO<E,Either<Tuple2<A,Fiber<EIO<E,?>,B>>,Tuple2<Fiber<EIO<E,?>,A>,B>>>	EIO.racePair(Executor executor, Kind<EIO<E,?>,? extends A> fa, Kind<EIO<E,?>,? extends B> fb)
static <R, E, A, B> PureIO<R,E,Either<Tuple2<A,Fiber<PureIO<R,E,?>,B>>,Tuple2<Fiber<PureIO<R,E,?>,A>,B>>>	PureIO.racePair(Executor executor, Kind<PureIO<R,E,?>,? extends A> fa, Kind<PureIO<R,E,?>,? extends B> fb)
static <R, A, B> RIO<R,Either<Tuple2<A,Fiber<RIO<R,?>,B>>,Tuple2<Fiber<RIO<R,?>,A>,B>>>	RIO.racePair(Executor executor, Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
static <A, B> Task<Either<Tuple2<A,Fiber<Task<?>,B>>,Tuple2<Fiber<Task<?>,A>,B>>>	Task.racePair(Executor executor, Kind<Task<?>,? extends A> fa, Kind<Task<?>,? extends B> fb)
static <A, B> UIO<Either<Tuple2<A,Fiber<UIO<?>,B>>,Tuple2<Fiber<UIO<?>,A>,B>>>	UIO.racePair(Executor executor, Kind<UIO<?>,? extends A> fa, Kind<UIO<?>,? extends B> fb)
static <R, A, B> URIO<R,Either<Tuple2<A,Fiber<URIO<R,?>,B>>,Tuple2<Fiber<URIO<R,?>,A>,B>>>	URIO.racePair(Executor executor, Kind<URIO<R,?>,? extends A> fa, Kind<URIO<R,?>,? extends B> fb)
static <R, A> PureIO<R,Throwable,A>	PureIO.redeem(Kind<PureIO<R,Void,?>,? extends A> value)
private static <R, E, A> Promise<Either<E,A>>	PureIO.runAsync(R env, Kind<PureIO<R,E,?>,A> current, PureIOConnection connection)
private static <R, E, F, G, A, B, C> Promise<Either<E,A>>	PureIO.runAsync(R env, Kind<PureIO<R,E,?>,A> current, PureIOConnection connection, CallStack<R,E,A> stack, Promise<Either<E,A>> promise)
static <E, A> EIO<E,A>	EIOOf.toEIO(Kind<EIO<E,?>,? extends A> value)
static <R, E, A> Managed<R,E,A>	ManagedOf.toManaged(Kind<Managed<R,E,?>,? extends A> value)
static <R, E, A> PureIO<R,E,A>	PureIOOf.toPureIO(Kind<PureIO<R,E,?>,? extends A> value)
static <R, A> RIO<R,A>	RIOOf.toRIO(Kind<RIO<R,?>,? extends A> value)
static <A> Task<A>	TaskOf.toTask(Kind<Task<?>,? extends A> value)
static <A> UIO<A>	UIOOf.toUIO(Kind<UIO<?>,? extends A> value)
static <R, A> URIO<R,A>	URIOOf.toURIO(Kind<URIO<R,?>,? extends A> value)
private static <R, E, F, A, B> Kind<PureIO<R,E,?>,A>	PureIO.unwrap(R env, Kind<PureIO<R,E,?>,A> current, CallStack<R,F,B> stack, Function1<Kind<PureIO<R,E,?>,? extends A>,Kind<PureIO<R,F,?>,? extends B>> next)
<B> EIO<E,Tuple2<A,B>>	EIO.zip(Kind<EIO<E,?>,? extends B> other)
default <B> PureIO<R,E,Tuple2<A,B>>	PureIO.zip(Kind<PureIO<R,E,?>,? extends B> other)
<B> RIO<R,Tuple2<A,B>>	RIO.zip(Kind<RIO<R,?>,? extends B> other)
<B> Task<Tuple2<A,B>>	Task.zip(Kind<Task<?>,? extends B> other)
<B> UIO<Tuple2<A,B>>	UIO.zip(Kind<UIO<?>,? extends B> other)
<B> URIO<R,Tuple2<A,B>>	URIO.zip(Kind<URIO<R,?>,? extends B> other)
<B> EIO<E,A>	EIO.zipLeft(Kind<EIO<E,?>,? extends B> other)
default <B> PureIO<R,E,A>	PureIO.zipLeft(Kind<PureIO<R,E,?>,? extends B> other)
<B> RIO<R,A>	RIO.zipLeft(Kind<RIO<R,?>,? extends B> other)
<B> Task<A>	Task.zipLeft(Kind<Task<?>,? extends B> other)
<B> UIO<A>	UIO.zipLeft(Kind<UIO<?>,? extends B> other)
<B> URIO<R,A>	URIO.zipLeft(Kind<URIO<R,?>,? extends B> other)
<B> EIO<E,B>	EIO.zipRight(Kind<EIO<E,?>,? extends B> other)
default <B> PureIO<R,E,B>	PureIO.zipRight(Kind<PureIO<R,E,?>,? extends B> other)
<B> RIO<R,B>	RIO.zipRight(Kind<RIO<R,?>,? extends B> other)
<B> Task<B>	Task.zipRight(Kind<Task<?>,? extends B> other)
<B> UIO<B>	UIO.zipRight(Kind<UIO<?>,? extends B> other)
<B> URIO<R,B>	URIO.zipRight(Kind<URIO<R,?>,? extends B> other)
<B, C> EIO<E,C>	EIO.zipWith(Kind<EIO<E,?>,? extends B> other, Function2<? super A,? super B,? extends C> mapper)
default <B, C> PureIO<R,E,C>	PureIO.zipWith(Kind<PureIO<R,E,?>,? extends B> other, Function2<? super A,? super B,? extends C> mapper)
<B, C> RIO<R,C>	RIO.zipWith(Kind<RIO<R,?>,? extends B> other, Function2<? super A,? super B,? extends C> mapper)
<B, C> Task<C>	Task.zipWith(Kind<Task<?>,? extends B> other, Function2<? super A,? super B,? extends C> mapper)
<B, C> UIO<C>	UIO.zipWith(Kind<UIO<?>,? extends B> other, Function2<? super A,? super B,? extends C> mapper)
<B, C> URIO<R,C>	URIO.zipWith(Kind<URIO<R,?>,? extends B> other, Function2<? super A,? super B,? extends C> mapper)

Method parameters in com.github.tonivade.purefun.effect with type arguments of type Kind

Modifier and Type	Method	Description
static <R, E, A> PureIO<R,E,A>	PureIO.accessM(Function1<? super R,? extends Kind<PureIO<R,E,?>,? extends A>> map)
static <R, A> RIO<R,A>	RIO.accessM(Function1<? super R,? extends Kind<RIO<R,?>,? extends A>> map)
static <R, A> URIO<R,A>	URIO.accessM(Function1<? super R,? extends Kind<URIO<R,?>,? extends A>> map)
void	CallStack.add(PartialFunction1<? super Throwable,? extends Kind<PureIO<R,E,?>,? extends A>> mapError)
void	StackItem.add(PartialFunction1<? super Throwable,? extends Kind<PureIO<R,E,?>,? extends A>> mapError)
static <E, A extends AutoCloseable, B> EIO<E,B>	EIO.bracket(Kind<EIO<E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> use)
static <E, A, B> EIO<E,B>	EIO.bracket(Kind<EIO<E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> use, Consumer1<? super A> release)
static <E, A, B> EIO<E,B>	EIO.bracket(Kind<EIO<E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> use, Function1<? super A,? extends Kind<EIO<E,?>,Unit>> release)
static <R, E, A extends AutoCloseable, B> PureIO<R,E,B>	PureIO.bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use)
static <R, E, A, B> PureIO<R,E,B>	PureIO.bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use, Consumer1<? super A> release)
static <R, E, A, B> PureIO<R,E,B>	PureIO.bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use, Function1<? super A,? extends Kind<PureIO<R,E,?>,Unit>> release)
static <R, A extends AutoCloseable, B> RIO<R,B>	RIO.bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use)
static <R, A, B> RIO<R,B>	RIO.bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use, Consumer1<? super A> release)
static <R, A, B> RIO<R,B>	RIO.bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use, Function1<? super A,? extends Kind<RIO<R,?>,Unit>> release)
static <A extends AutoCloseable, B> Task<B>	Task.bracket(Kind<Task<?>,? extends A> acquire, Function1<? super A,? extends Kind<Task<?>,? extends B>> use)
static <A, B> Task<B>	Task.bracket(Kind<Task<?>,? extends A> acquire, Function1<? super A,? extends Kind<Task<?>,? extends B>> use, Consumer1<? super A> release)
static <A, B> Task<B>	Task.bracket(Kind<Task<?>,? extends A> acquire, Function1<? super A,? extends Kind<Task<?>,? extends B>> use, Function1<? super A,? extends Kind<Task<?>,Unit>> release)
static <A extends AutoCloseable, B> UIO<B>	UIO.bracket(Kind<UIO<?>,? extends A> acquire, Function1<? super A,? extends Kind<UIO<?>,? extends B>> use)
static <A, B> UIO<B>	UIO.bracket(Kind<UIO<?>,? extends A> acquire, Function1<? super A,? extends Kind<UIO<?>,? extends B>> use, Consumer1<? super A> release)
static <A, B> UIO<B>	UIO.bracket(Kind<UIO<?>,? extends A> acquire, Function1<? super A,? extends Kind<UIO<?>,? extends B>> use, Function1<? super A,? extends Kind<UIO<?>,Unit>> release)
static <R, A extends AutoCloseable, B> URIO<R,B>	URIO.bracket(Kind<URIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> use)
static <R, A, B> URIO<R,B>	URIO.bracket(Kind<URIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> use, Consumer1<? super A> release)
static <R, A, B> URIO<R,B>	URIO.bracket(Kind<URIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> use, Function1<? super A,? extends Kind<URIO<R,?>,Unit>> release)
static <E, A> EIO<E,A>	EIO.defer(Producer<Kind<EIO<E,?>,? extends A>> lazy)
static <R, E, A> PureIO<R,E,A>	PureIO.defer(Producer<Kind<PureIO<R,E,?>,? extends A>> lazy)
static <R, A> RIO<R,A>	RIO.defer(Producer<Kind<RIO<R,?>,? extends A>> lazy)
static <A> Task<A>	Task.defer(Producer<? extends Kind<Task<?>,? extends A>> lazy)
static <A> UIO<A>	UIO.defer(Producer<Kind<UIO<?>,? extends A>> lazy)
static <R, A> URIO<R,A>	URIO.defer(Producer<Kind<URIO<R,?>,? extends A>> lazy)
<B> EIO<E,B>	EIO.flatMap(Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> map)
<B> Managed<R,E,B>	Managed.flatMap(Function1<? super A,? extends Kind<Managed<R,E,?>,? extends B>> mapper)
default <B> PureIO<R,E,B>	PureIO.flatMap(Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> map)
<B> RIO<R,B>	RIO.flatMap(Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> map)
<B> Task<B>	Task.flatMap(Function1<? super A,? extends Kind<Task<?>,? extends B>> map)
<B> UIO<B>	UIO.flatMap(Function1<? super A,? extends Kind<UIO<?>,? extends B>> map)
<B> URIO<R,B>	URIO.flatMap(Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> map)
<F> EIO<F,A>	EIO.flatMapError(Function1<? super E,? extends Kind<EIO<F,?>,? extends A>> map)
<F> Managed<R,F,A>	Managed.flatMapError(Function1<? super E,? extends Kind<Managed<R,F,?>,? extends A>> mapper)
default <F> PureIO<R,F,A>	PureIO.flatMapError(Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends A>> map)
<B, F> EIO<F,B>	EIO.foldM(Function1<? super E,? extends Kind<EIO<F,?>,? extends B>> mapError, Function1<? super A,? extends Kind<EIO<F,?>,? extends B>> map)
<F, B> Managed<R,F,B>	Managed.foldM(Function1<? super E,? extends Kind<Managed<R,F,?>,? extends B>> mapError, Function1<? super A,? extends Kind<Managed<R,F,?>,? extends B>> mapper)
default <F, B> PureIO<R,F,B>	PureIO.foldM(Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends B>> left, Function1<? super A,? extends Kind<PureIO<R,F,?>,? extends B>> right)
<B> RIO<R,B>	RIO.foldM(Function1<? super Throwable,? extends Kind<RIO<R,?>,? extends B>> mapError, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> map)
<B> Task<B>	Task.foldM(Function1<? super Throwable,? extends Kind<Task<?>,? extends B>> mapError, Function1<? super A,? extends Kind<Task<?>,? extends B>> map)
<B> UIO<B>	UIO.redeemWith(Function1<? super Throwable,? extends Kind<UIO<?>,? extends B>> mapError, Function1<? super A,? extends Kind<UIO<?>,? extends B>> map)
<B> URIO<R,B>	URIO.redeemWith(Function1<? super Throwable,? extends Kind<URIO<R,?>,? extends B>> mapError, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> map)
static <E, A> EIO<E,Sequence<A>>	EIO.traverse(Sequence<? extends Kind<EIO<E,?>,? extends A>> sequence)
static <E, A> EIO<E,Sequence<A>>	EIO.traverse(Executor executor, Sequence<? extends Kind<EIO<E,?>,? extends A>> sequence)
static <R, E, A> PureIO<R,E,Sequence<A>>	PureIO.traverse(Sequence<? extends Kind<PureIO<R,E,?>,A>> sequence)
static <R, E, A> PureIO<R,E,Sequence<A>>	PureIO.traverse(Executor executor, Sequence<? extends Kind<PureIO<R,E,?>,A>> sequence)
static <R, A> RIO<R,Sequence<A>>	RIO.traverse(Sequence<? extends Kind<RIO<R,?>,A>> sequence)
static <R, A> RIO<R,Sequence<A>>	RIO.traverse(Executor executor, Sequence<? extends Kind<RIO<R,?>,A>> sequence)
static <A> Task<Sequence<A>>	Task.traverse(Sequence<? extends Kind<Task<?>,A>> sequence)
static <A> Task<Sequence<A>>	Task.traverse(Executor executor, Sequence<? extends Kind<Task<?>,A>> sequence)
static <A> UIO<Sequence<A>>	UIO.traverse(Sequence<? extends Kind<UIO<?>,A>> sequence)
static <A> UIO<Sequence<A>>	UIO.traverse(Executor executor, Sequence<? extends Kind<UIO<?>,A>> sequence)
static <R, A> URIO<R,Sequence<A>>	URIO.traverse(Sequence<? extends Kind<URIO<R,?>,A>> sequence)
static <R, A> URIO<R,Sequence<A>>	URIO.traverse(Executor executor, Sequence<? extends Kind<URIO<R,?>,A>> sequence)
private static <R, E, F, A, B> Kind<PureIO<R,E,?>,A>	PureIO.unwrap(R env, Kind<PureIO<R,E,?>,A> current, CallStack<R,F,B> stack, Function1<Kind<PureIO<R,E,?>,? extends A>,Kind<PureIO<R,F,?>,? extends B>> next)
private static <R, E, F, A, B> Kind<PureIO<R,E,?>,A>	PureIO.unwrap(R env, Kind<PureIO<R,E,?>,A> current, CallStack<R,F,B> stack, Function1<Kind<PureIO<R,E,?>,? extends A>,Kind<PureIO<R,F,?>,? extends B>> next)

Constructor parameters in com.github.tonivade.purefun.effect with type arguments of type Kind

Modifier	Constructor	Description
private	AccessM(Function1<? super R,? extends Kind<PureIO<R,E,?>,? extends A>> function)
private	FlatMapped(PureIO<R,E,A> current, Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends B>> nextError, Function1<? super A,? extends Kind<PureIO<R,F,?>,? extends B>> next)
private	Suspend(Producer<Kind<PureIO<R,E,?>,? extends A>> lazy)

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

Classes in com.github.tonivade.purefun.free with type parameters of type Kind

Modifier and Type	Class	Description
final class	EitherK<F extends Kind<F,?>,G extends Kind<G,?>,T>
final class	EitherK<F extends Kind<F,?>,G extends Kind<G,?>,T>
interface	EitherKOf<F extends Kind<F,?>,G extends Kind<G,?>,T>
interface	EitherKOf<F extends Kind<F,?>,G extends Kind<G,?>,T>
interface	Free<F extends Kind<F,?>,A>
static final record	Free.FlatMapped<F extends Kind<F,?>,A,B>
static final record	Free.Pure<F extends Kind<F,?>,A>
static final record	Free.Suspend<F extends Kind<F,?>,A>
interface	FreeAp<F extends Kind<F,?>,A>
static final record	FreeAp.Apply<F extends Kind<F,?>,A,B>
static final record	FreeAp.CurriedFunction<G extends Kind<G,?>,A,B>
static final record	FreeAp.Lift<F extends Kind<F,?>,A>
static final record	FreeAp.Pure<F extends Kind<F,?>,A>
interface	FreeApOf<F extends Kind<F,?>,A>
(package private) interface	FreeApplicative<F extends Kind<F,?>>
(package private) interface	FreeMonad<F extends Kind<F,?>>
interface	FreeOf<F extends Kind<F,?>,A>

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

Modifier and Type	Interface	Description
interface	EitherKOf<F extends Kind<F,?>,G extends Kind<G,?>,T>
interface	Free<F extends Kind<F,?>,A>
interface	FreeAp<F extends Kind<F,?>,A>
interface	FreeApOf<F extends Kind<F,?>,A>
interface	FreeOf<F extends Kind<F,?>,A>

Classes in com.github.tonivade.purefun.free that implement Kind

Modifier and Type	Class	Description
final class	EitherK<F extends Kind<F,?>,G extends Kind<G,?>,T>
static final record	Free.FlatMapped<F extends Kind<F,?>,A,B>
static final record	Free.Pure<F extends Kind<F,?>,A>
static final record	Free.Suspend<F extends Kind<F,?>,A>
static final record	FreeAp.Apply<F extends Kind<F,?>,A,B>
static final record	FreeAp.Lift<F extends Kind<F,?>,A>
static final record	FreeAp.Pure<F extends Kind<F,?>,A>

Fields in com.github.tonivade.purefun.free declared as Kind

Modifier and Type	Field	Description
private final Kind<F,? extends A>	Free.Suspend.value	The field for the value record component.
private final Kind<G,Function1<A,B>>	FreeAp.CurriedFunction.value	The field for the value record component.
private final Kind<F,A>	FreeAp.Lift.value	The field for the value record component.

Fields in com.github.tonivade.purefun.free with type parameters of type Kind

Modifier and Type	Field	Description
private final Either<Kind<F,T>,Kind<G,T>>	EitherK.either
private final Either<Kind<F,T>,Kind<G,T>>	EitherK.either
private final Function1<? super A,? extends Kind<Free<F,?>,? extends B>>	Free.FlatMapped.next	The field for the next record component.

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

Modifier and Type	Method	Description
static <F extends Kind<F, ?>> Applicative<FreeAp<F,?>>	FreeAp.applicativeF()
static <F extends Kind<F, ?>, T, R> FreeAp<F,R>	FreeAp.apply(Kind<FreeAp<F,?>,? extends T> value, Kind<FreeAp<F,?>,? extends Function1<? super T,? extends R>> mapper)
default <G extends Kind<G, ?>> FreeAp<G,A>	FreeAp.compile(FunctionK<F,G> transformer)
static <F extends Kind<F, ?>, T> Free<F,T>	Free.defer(Producer<? extends Free<F,? extends T>> value)
default <G extends Kind<G, ?>> FreeAp<G,A>	FreeAp.flatCompile(FunctionK<F,FreeAp<G,?>> functionK, Applicative<FreeAp<G,?>> applicative)
private static <F extends Kind<F, ?>, G extends Kind<G, ?>, A> Kind<G,A>	FreeAp.foldArg(FreeAp<F,A> argF, FunctionK<F,G> transformation, Applicative<G> applicative)
private static <F extends Kind<F, ?>, G extends Kind<G, ?>, A> Kind<G,A>	FreeAp.foldArg(FreeAp<F,A> argF, FunctionK<F,G> transformation, Applicative<G> applicative)
<R extends Kind<R, ?>> Kind<R,T>	EitherK.foldK(FunctionK<F,R> left, FunctionK<G,R> right)
default <G extends Kind<G, ?>> Kind<G,A>	Free.foldMap(Monad<G> monad, FunctionK<F,G> interpreter)
default <G extends Kind<G, ?>> Kind<G,A>	FreeAp.foldMap(FunctionK<F,G> functionK, Applicative<G> applicative)
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)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> FunctionK<F,Free<G,?>>	Free.functionKF(FunctionK<F,G> functionK)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> FunctionK<F,Free<G,?>>	Free.functionKF(FunctionK<F,G> functionK)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> FunctionK<F,FreeAp<G,?>>	FreeAp.functionKF(FunctionK<F,G> functionK)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> FunctionK<F,FreeAp<G,?>>	FreeAp.functionKF(FunctionK<F,G> functionK)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> Free<G,T>	Free.inject(InjectK<F,G> inject, Kind<F,T> value)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> Free<G,T>	Free.inject(InjectK<F,G> inject, Kind<F,T> value)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> EitherK<F,G,T>	EitherK.left(Kind<F,T> left)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> EitherK<F,G,T>	EitherK.left(Kind<F,T> left)
static <F extends Kind<F, ?>, T> FreeAp<F,T>	FreeAp.lift(Kind<F,T> value)
static <F extends Kind<F, ?>, T> Free<F,T>	Free.liftF(Kind<F,? extends T> value)
<X extends Kind<X, ?>> EitherK<F,X,T>	EitherK.mapK(FunctionK<G,X> mapper)
<X extends Kind<X, ?>> EitherK<X,G,T>	EitherK.mapLeftK(FunctionK<F,X> mapper)
static <F extends Kind<F, ?>> Monad<Free<F,?>>	Free.monadF()
static <F extends Kind<F, ?>, T> Free<F,T>	Free.pure(T value)
static <F extends Kind<F, ?>, T> FreeAp<F,T>	FreeAp.pure(T value)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> EitherK<F,G,T>	EitherK.right(Kind<G,T> right)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> EitherK<F,G,T>	EitherK.right(Kind<G,T> right)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> EitherK<F,G,T>	EitherKOf.toEitherK(Kind<EitherK<F,G,?>,? extends T> value)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> EitherK<F,G,T>	EitherKOf.toEitherK(Kind<EitherK<F,G,?>,? extends T> value)
static <F extends Kind<F, ?>, A> Free<F,A>	FreeOf.toFree(Kind<Free<F,?>,? extends A> value)
static <F extends Kind<F, ?>, A> FreeAp<F,A>	FreeApOf.toFreeAp(Kind<FreeAp<F,?>,? extends A> value)

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

Modifier and Type	Method	Description
default Kind<F,A>	FreeAp.fold(Applicative<F> applicative)
private static <F extends Kind<F, ?>, G extends Kind<G, ?>, A> Kind<G,A>	FreeAp.foldArg(FreeAp<F,A> argF, FunctionK<F,G> transformation, Applicative<G> applicative)
<R extends Kind<R, ?>> Kind<R,T>	EitherK.foldK(FunctionK<F,R> left, FunctionK<G,R> right)
default <G extends Kind<G, ?>> Kind<G,A>	Free.foldMap(Monad<G> monad, FunctionK<F,G> interpreter)
default <G extends Kind<G, ?>> Kind<G,A>	FreeAp.foldMap(FunctionK<F,G> functionK, Applicative<G> applicative)
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)
Kind<F,T>	EitherK.getLeft()
Kind<G,T>	EitherK.getRight()
Kind<F,? extends A>	Free.Suspend.value()	Returns the value of the value record component.
Kind<G,Function1<A,B>>	FreeAp.CurriedFunction.value()	Returns the value of the value record component.
Kind<F,A>	FreeAp.Lift.value()	Returns the value of the value record component.

Methods in com.github.tonivade.purefun.free that return types with arguments of type Kind

Modifier and Type	Method	Description
Function1<? super A,? extends Kind<Free<F,?>,? extends B>>	Free.FlatMapped.next()	Returns the value of the next record component.

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

Modifier and Type	Method	Description
default <R> Free<F,R>	Free.andThen(Kind<Free<F,?>,? extends R> next)
default <B> FreeAp<F,B>	FreeAp.ap(Kind<FreeAp<F,?>,? extends Function1<? super A,? extends B>> apply)
default <T, R> FreeAp<F,R>	FreeApplicative.ap(Kind<FreeAp<F,?>,? extends T> value, Kind<FreeAp<F,?>,? extends Function1<? super T,? extends R>> apply)
static <F extends Kind<F, ?>, T, R> FreeAp<F,R>	FreeAp.apply(Kind<FreeAp<F,?>,? extends T> value, Kind<FreeAp<F,?>,? extends Function1<? super T,? extends R>> mapper)
default <T, R> Free<F,R>	FreeMonad.flatMap(Kind<Free<F,?>,? extends T> value, Function1<? super T,? extends Kind<Free<F,?>,? extends R>> map)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> Free<G,T>	Free.inject(InjectK<F,G> inject, Kind<F,T> value)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> EitherK<F,G,T>	EitherK.left(Kind<F,T> left)
static <F extends Kind<F, ?>, T> FreeAp<F,T>	FreeAp.lift(Kind<F,T> value)
static <F extends Kind<F, ?>, T> Free<F,T>	Free.liftF(Kind<F,? extends T> value)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> EitherK<F,G,T>	EitherK.right(Kind<G,T> right)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> EitherK<F,G,T>	EitherKOf.toEitherK(Kind<EitherK<F,G,?>,? extends T> value)
static <F extends Kind<F, ?>, A> Free<F,A>	FreeOf.toFree(Kind<Free<F,?>,? extends A> value)
static <F extends Kind<F, ?>, A> FreeAp<F,A>	FreeApOf.toFreeAp(Kind<FreeAp<F,?>,? extends A> value)

Method parameters in com.github.tonivade.purefun.free with type arguments of type Kind

Modifier and Type	Method	Description
<R> Free<F,R>	Free.flatMap(Function1<? super A,? extends Kind<Free<F,?>,? extends R>> mapper)
<C> Free<F,C>	Free.FlatMapped.flatMap(Function1<? super B,? extends Kind<Free<F,?>,? extends C>> map)
<B> Free<F,B>	Free.Pure.flatMap(Function1<? super A,? extends Kind<Free<F,?>,? extends B>> map)
<B> Free<F,B>	Free.Suspend.flatMap(Function1<? super A,? extends Kind<Free<F,?>,? extends B>> map)
default <T, R> Free<F,R>	FreeMonad.flatMap(Kind<Free<F,?>,? extends T> value, Function1<? super T,? extends Kind<Free<F,?>,? extends R>> map)

Constructors in com.github.tonivade.purefun.free with parameters of type Kind

Modifier	Constructor	Description
	CurriedFunction(Kind<G,Function1<A,B>> value, int remaining)	Creates an instance of a CurriedFunction record class.
	Lift(Kind<F,A> value)	Creates an instance of a Lift record class.
	Suspend(Kind<F,? extends A> value)	Creates an instance of a Suspend record class.

Constructor parameters in com.github.tonivade.purefun.free with type arguments of type Kind

Modifier	Constructor	Description
private	EitherK(Either<Kind<F,T>,Kind<G,T>> either)
private	EitherK(Either<Kind<F,T>,Kind<G,T>> either)
	FlatMapped(Free<F,? extends A> value, Function1<? super A,? extends Kind<Free<F,?>,? extends B>> next)	Creates an instance of a FlatMapped record class.

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

Classes in com.github.tonivade.purefun.instances with type parameters of type Kind

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>
(package private) interface	EitherKComonad<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	EitherKComonad<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	EitherKContravariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	EitherKContravariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	EitherKFunctor<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	EitherKFunctor<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	EitherKInjectKLeft<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	EitherKInjectKLeft<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	EitherKInjectKRight<F extends Kind<F,?>,G extends Kind<G,?>,R extends Kind<R,?>>
(package private) interface	EitherKInjectKRight<F extends Kind<F,?>,G extends Kind<G,?>,R extends Kind<R,?>>
(package private) interface	EitherKInjectKRight<F extends Kind<F,?>,G extends Kind<G,?>,R extends Kind<R,?>>
(package private) interface	EitherTBracket<F extends Kind<F,?>,E>
(package private) interface	EitherTDefer<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	EitherTTimer<F extends Kind<F,?>>
(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>
class	MonadMTL<F extends Kind<F,?>,S,R,E>
static final class	MonadMTL.EffectE<F extends Kind<F,?>,E,A>
static final class	MonadMTL.EffectR<F extends Kind<F,?>,R,E,A>
static final class	MonadMTL.EffectS<F extends Kind<F,?>,S,R,E,A>
(package private) interface	OptionTBracket<F extends Kind<F,?>>
(package private) interface	OptionTDefer<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	PureStreamFunctor<F extends Kind<F,?>>
(package private) interface	PureStreamMonad<F extends Kind<F,?>>
(package private) interface	PureStreamPure<F extends Kind<F,?>>
(package private) interface	ScheduleFunctor<F extends Kind<F,?>,A>
(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	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>

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

Modifier and Type	Interface	Description
(package private) interface	SequenceMonoid<T>

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

Modifier and Type	Class	Description
static final class	MonadMTL.EffectE<F extends Kind<F,?>,E,A>
static final class	MonadMTL.EffectR<F extends Kind<F,?>,R,E,A>
static final class	MonadMTL.EffectS<F extends Kind<F,?>,S,R,E,A>

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

Modifier and Type	Method	Description
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Comonad<EitherK<F,G,?>>	EitherKInstances.comonad(Comonad<F> comonadF, Comonad<G> comonadG)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Comonad<EitherK<F,G,?>>	EitherKInstances.comonad(Comonad<F> comonadF, Comonad<G> comonadG)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Contravariant<EitherK<F,G,?>>	EitherKInstances.contravariant(Contravariant<F> contravariantF, Contravariant<G> contravariantG)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Contravariant<EitherK<F,G,?>>	EitherKInstances.contravariant(Contravariant<F> contravariantF, Contravariant<G> contravariantG)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> Eq<Kind<EitherK<F,G,?>,T>>	EitherKInstances.eq(Eq<Kind<F,T>> leftEq, Eq<Kind<G,T>> rightEq)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> Eq<Kind<EitherK<F,G,?>,T>>	EitherKInstances.eq(Eq<Kind<F,T>> leftEq, Eq<Kind<G,T>> rightEq)
static <F extends Kind<F, ?>, L, R> Eq<Kind<EitherT<F,L,?>,R>>	EitherTInstances.eq(Eq<Kind<F,Either<L,R>>> eq)
static <F extends Kind<F, ?>, T> Eq<Kind<OptionT<F,?>,T>>	OptionTInstances.eq(Eq<Kind<F,Option<T>>> eq)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Functor<EitherK<F,G,?>>	EitherKInstances.functor(Functor<F> functorF, Functor<G> functorG)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Functor<EitherK<F,G,?>>	EitherKInstances.functor(Functor<F> functorF, Functor<G> functorG)
static <F extends Kind<F, ?>> Functor<PureStream<F,?>>	PureStreamInstances.functor()
static <F extends Kind<F, ?>, A> Functor<Schedule<F,A,?>>	ScheduleInstances.functor()
static <F extends Kind<F, ?>, G extends Kind<G, ?>> InjectK<F,EitherK<F,G,?>>	EitherKInstances.injectEitherKLeft()
static <F extends Kind<F, ?>, G extends Kind<G, ?>> InjectK<F,EitherK<F,G,?>>	EitherKInstances.injectEitherKLeft()
static <F extends Kind<F, ?>, R extends Kind<R, ?>, G extends Kind<G, ?>> InjectK<F,EitherK<G,R,?>>	EitherKInstances.injectEitherKRight(InjectK<F,R> inject)
static <F extends Kind<F, ?>, R extends Kind<R, ?>, G extends Kind<G, ?>> InjectK<F,EitherK<G,R,?>>	EitherKInstances.injectEitherKRight(InjectK<F,R> inject)
static <F extends Kind<F, ?>, R extends Kind<R, ?>, G extends Kind<G, ?>> InjectK<F,EitherK<G,R,?>>	EitherKInstances.injectEitherKRight(InjectK<F,R> inject)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> EitherKComonad<F,G>	EitherKComonad.instance(Comonad<F> comonadF, Comonad<G> comonadG)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> EitherKComonad<F,G>	EitherKComonad.instance(Comonad<F> comonadF, Comonad<G> comonadG)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> EitherKContravariant<F,G>	EitherKContravariant.instance(Contravariant<F> contravariantF, Contravariant<G> contravariantG)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> EitherKContravariant<F,G>	EitherKContravariant.instance(Contravariant<F> contravariantF, Contravariant<G> contravariantG)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> EitherKFunctor<F,G>	EitherKFunctor.instance(Functor<F> functorF, Functor<G> functorG)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> EitherKFunctor<F,G>	EitherKFunctor.instance(Functor<F> functorF, Functor<G> functorG)
static <F extends Kind<F, ?>, X extends Kind<X, ?>, R extends Kind<R, ?>> EitherKInjectKRight<F,X,R>	EitherKInjectKRight.instance(InjectK<F,R> injectK)
static <F extends Kind<F, ?>, X extends Kind<X, ?>, R extends Kind<R, ?>> EitherKInjectKRight<F,X,R>	EitherKInjectKRight.instance(InjectK<F,R> injectK)
static <F extends Kind<F, ?>, X extends Kind<X, ?>, R extends Kind<R, ?>> EitherKInjectKRight<F,X,R>	EitherKInjectKRight.instance(InjectK<F,R> injectK)
static <F extends Kind<F, ?>, L> EitherTMonad<F,L>	EitherTMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>> EitherTMonadDefer<F>	EitherTMonadDefer.instance(MonadDefer<F> monadDeferF)
static <F extends Kind<F, ?>, L> EitherTMonadErrorFromMonad<F,L>	EitherTMonadErrorFromMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>, E> EitherTMonadErrorFromMonadError<F,E>	EitherTMonadErrorFromMonadError.instance(MonadError<F,E> monadErrorF)
static <F extends Kind<F, ?>> EitherTMonadThrowFromMonad<F>	EitherTMonadThrowFromMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>> EitherTMonadThrowFromMonadThrow<F>	EitherTMonadThrowFromMonadThrow.instance(MonadThrow<F> monadThrowF)
static <F extends Kind<F, ?>, Z> KleisliMonad<F,Z>	KleisliMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>, R, E> KleisliMonadError<F,R,E>	KleisliMonadError.instance(MonadError<F,E> monadErrorF)
static <F extends Kind<F, ?>, Z> KleisliMonadReader<F,Z>	KleisliMonadReader.instance(Monad<F> monadF)
static <F extends Kind<F, ?>, R, S> KleisliMonadState<F,R,S>	KleisliMonadState.instance(MonadState<F,S> monadStateF)
static <F extends Kind<F, ?>> OptionTMonad<F>	OptionTMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>> OptionTMonadDefer<F>	OptionTMonadDefer.instance(MonadDefer<F> monadDeferF)
static <F extends Kind<F, ?>> OptionTMonadErrorFromMonad<F>	OptionTMonadErrorFromMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>, E> OptionTMonadErrorFromMonadError<F,E>	OptionTMonadErrorFromMonadError.instance(MonadError<F,E> monadF)
static <F extends Kind<F, ?>> OptionTMonadThrow<F>	OptionTMonadThrow.instance(MonadThrow<F> monadThrowF)
static <F extends Kind<F, ?>> PureStreamMonad<F>	PureStreamMonad.instance(PureStream.Of<F> streamOf)
static <F extends Kind<F, ?>, S> StateTMonad<F,S>	StateTMonad.instance(Monad<F> monadF)
static <F extends Kind<F, ?>, S, E> StateTMonadError<F,S,E>	StateTMonadError.instance(MonadError<F,E> monadErrorF)
static <F extends Kind<F, ?>, S, R> StateTMonadReader<F,S,R>	StateTMonadReader.instance(MonadReader<F,R> monadReaderF)
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, E> MonadError<WriterT<F,L,?>,E>	WriterTMonadError.instance(Monoid<L> monoid, MonadError<F,E> monadErrorF)
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, ?>> Monad<PureStream<F,?>>	PureStreamInstances.monad(PureStream.Of<F> streamOf)
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, ?>> MonadDefer<EitherT<F,Throwable,?>>	EitherTInstances.monadDefer(MonadDefer<F> monadDeferF)
static <F extends Kind<F, ?>> MonadDefer<OptionT<F,?>>	OptionTInstances.monadDefer(MonadDefer<F> monadDeferF)
static <F extends Kind<F, ?>, L> MonadError<EitherT<F,L,?>,L>	EitherTInstances.monadError(Monad<F> monadF)
static <F extends Kind<F, ?>, L> MonadError<EitherT<F,L,?>,L>	EitherTInstances.monadError(MonadError<F,L> monadErrorF)
static <F extends Kind<F, ?>, Z, E> MonadError<Kleisli<F,Z,?>,E>	KleisliInstances.monadError(MonadError<F,E> monadErrorF)
static <F extends Kind<F, ?>> MonadError<OptionT<F,?>,Unit>	OptionTInstances.monadError(Monad<F> monadF)
static <F extends Kind<F, ?>, E> MonadError<OptionT<F,?>,E>	OptionTInstances.monadError(MonadError<F,E> monadErrorF)
static <F extends Kind<F, ?>, S, E> MonadError<StateT<F,S,?>,E>	StateTInstances.monadError(MonadError<F,E> monadErrorF)
static <F extends Kind<F, ?>, L, E> MonadError<WriterT<F,L,?>,E>	WriterTInstances.monadError(Monoid<L> monoid, MonadError<F,E> monadErrorF)
static <F extends Kind<F, ?>, Z> MonadReader<Kleisli<F,Z,?>,Z>	KleisliInstances.monadReader(Monad<F> monadF)
static <F extends Kind<F, ?>, S, R> MonadReader<StateT<F,S,?>,R>	StateTInstances.monadReader(MonadReader<F,R> monadReaderF)
static <F extends Kind<F, ?>, Z, S> MonadState<Kleisli<F,Z,?>,S>	KleisliInstances.monadState(MonadState<F,S> monadStateF)
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, ?>> MonadThrow<EitherT<F,Throwable,?>>	EitherTInstances.monadThrow(MonadThrow<F> monadF)
static <F extends Kind<F, ?>> MonadThrow<OptionT<F,?>>	OptionTInstances.monadThrow(MonadThrow<F> monadThrowF)
static <F extends Kind<F, ?>, L> MonadWriter<WriterT<F,L,?>,L>	WriterTInstances.monadWriter(Monoid<L> monoid, Monad<F> monadF)
static <F extends Kind<F, ?>, A> Reference<OptionT<F,?>,A>	OptionTInstances.ref(MonadDefer<F> monadF, A value)
static <F extends Kind<F, ?>, A> Reference<EitherT<F,Throwable,?>,A>	EitherTInstances.refFromMonadThrow(MonadDefer<F> monadDeferF, A value)
<R extends Kind<F, Either<E, A>>> R	MonadMTL.EffectE.run(Function<Kind<F,? extends Either<E,A>>,R> fixer)
static <F extends Kind<F, ?>, E, A> MonadMTL.EffectE<F,E,A>	MonadMTL.EffectE.toEffectE(Kind<MonadMTL.EffectE<F,E,?>,? extends A> hkt)
static <F extends Kind<F, ?>, R, E, A> MonadMTL.EffectR<F,R,E,A>	MonadMTL.EffectR.toEffectR(Kind<MonadMTL.EffectR<F,R,E,?>,? extends A> hkt)
static <F extends Kind<F, ?>, S, R, E, A> MonadMTL.EffectS<F,S,R,E,A>	MonadMTL.EffectS.toEffectS(Kind<MonadMTL.EffectS<F,S,R,E,?>,? extends A> hkt)
default <G extends Kind<G, ?>, A, B> Kind<G,Kind<Const<T,?>,B>>	ConstTraverse.traverse(Applicative<G> applicative, Kind<Const<T,?>,A> value, Function1<? super A,? extends Kind<G,? extends B>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Either<L,?>,R>>	EitherTraverse.traverse(Applicative<G> applicative, Kind<Either<L,?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Id<?>,R>>	IdTraverse.traverse(Applicative<G> applicative, Kind<Id<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Option<?>,R>>	OptionTraverse.traverse(Applicative<G> applicative, Kind<Option<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Sequence<?>,R>>	SequenceTraverse.traverse(Applicative<G> applicative, Kind<Sequence<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Try<?>,R>>	TryTraverse.traverse(Applicative<G> applicative, Kind<Try<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)

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

Modifier and Type	Method	Description
<A> Kind<F,Either<E,A>>	EitherTBracket.acquireRecover(E error)
default <A> Kind<F,Either<Throwable,A>>	EitherTMonadDefer.acquireRecover(Throwable error)
default <T, R> Kind<Eval<?>,R>	EvalApplicative.ap(Kind<Eval<?>,? extends T> value, Kind<Eval<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Future<?>,R>	FutureApplicative.ap(Kind<Future<?>,? extends T> value, Kind<Future<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Future<?>,R>	FutureMonad.ap(Kind<Future<?>,? extends T> value, Kind<Future<?>,? extends Function1<? super T,? extends R>> apply)	XXX In order to create real parallel computations, we need to override ap to use the applicative version of the ap method
default <T, R> Kind<Id<?>,R>	IdApplicative.ap(Kind<Id<?>,? extends T> value, Kind<Id<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Option<?>,R>	OptionApplicative.ap(Kind<Option<?>,? extends T> value, Kind<Option<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Producer<?>,R>	ProducerApplicative.ap(Kind<Producer<?>,? extends T> value, Kind<Producer<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Promise<?>,R>	PromiseApplicative.ap(Kind<Promise<?>,? extends T> value, Kind<Promise<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Promise<?>,R>	PromiseMonad.ap(Kind<Promise<?>,? extends T> value, Kind<Promise<?>,? extends Function1<? super T,? extends R>> apply)	XXX In order to create real parallel computations, we need to override ap to use the applicative version of the ap method
default <T, R> Kind<Sequence<?>,R>	SequenceApplicative.ap(Kind<Sequence<?>,? extends T> value, Kind<Sequence<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Trampoline<?>,R>	TrampolineApplicative.ap(Kind<Trampoline<?>,? extends T> value, Kind<Trampoline<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Try<?>,R>	TryApplicative.ap(Kind<Try<?>,? extends T> value, Kind<Try<?>,? extends Function1<? super T,? extends R>> apply)
default Kind<Reader<R,?>,R>	ReaderMonadReader.ask()
default <A, B> Kind<Eval<?>,B>	EvalComonad.coflatMap(Kind<Eval<?>,? extends A> value, Function1<? super Kind<Eval<?>,? extends A>,? extends B> map)
default <A, B> Kind<Id<?>,B>	IdComonad.coflatMap(Kind<Id<?>,? extends A> value, Function1<? super Kind<Id<?>,? extends A>,? extends B> map)
default <A, B> Kind<Producer<?>,B>	ProducerComonad.coflatMap(Kind<Producer<?>,? extends A> value, Function1<? super Kind<Producer<?>,? extends A>,? extends B> map)
default <T> Kind<Option<?>,T>	OptionSemigroupK.combineK(Kind<Option<?>,? extends T> t1, Kind<Option<?>,? extends T> t2)
default <T> Kind<Sequence<?>,T>	SequenceSemigroupK.combineK(Kind<Sequence<?>,? extends T> t1, Kind<Sequence<?>,? extends T> t2)
default <A> Kind<Eval<?>,A>	EvalDefer.defer(Producer<? extends Kind<Eval<?>,? extends A>> defer)
default <A> Kind<Trampoline<?>,A>	TrampolineDefer.defer(Producer<? extends Kind<Trampoline<?>,? extends A>> defer)
default <T, R> Kind<Eval<?>,R>	EvalMonad.flatMap(Kind<Eval<?>,? extends T> value, Function1<? super T,? extends Kind<Eval<?>,? extends R>> map)
default <T, R> Kind<Future<?>,R>	FutureMonad.flatMap(Kind<Future<?>,? extends T> value, Function1<? super T,? extends Kind<Future<?>,? extends R>> map)
default <T, R> Kind<Id<?>,R>	IdMonad.flatMap(Kind<Id<?>,? extends T> value, Function1<? super T,? extends Kind<Id<?>,? extends R>> map)
default <T, R> Kind<Option<?>,R>	OptionMonad.flatMap(Kind<Option<?>,? extends T> value, Function1<? super T,? extends Kind<Option<?>,? extends R>> map)
default <T, R> Kind<Producer<?>,R>	ProducerMonad.flatMap(Kind<Producer<?>,? extends T> value, Function1<? super T,? extends Kind<Producer<?>,? extends R>> mapper)
default <T, R> Kind<Promise<?>,R>	PromiseMonad.flatMap(Kind<Promise<?>,? extends T> value, Function1<? super T,? extends Kind<Promise<?>,? extends R>> map)
default <T, R> Kind<Sequence<?>,R>	SequenceMonad.flatMap(Kind<Sequence<?>,? extends T> value, Function1<? super T,? extends Kind<Sequence<?>,? extends R>> map)
default <T, R> Kind<Trampoline<?>,R>	TrampolineMonad.flatMap(Kind<Trampoline<?>,? extends T> value, Function1<? super T,? extends Kind<Trampoline<?>,? extends R>> map)
default <T, R> Kind<Try<?>,R>	TryMonad.flatMap(Kind<Try<?>,? extends T> value, Function1<? super T,? extends Kind<Try<?>,? extends R>> map)
default <A> Kind<Eval<?>,A>	EvalMonadError.handleErrorWith(Kind<Eval<?>,A> value, Function1<? super Throwable,? extends Kind<Eval<?>,? extends A>> handler)
default <A> Kind<Future<?>,A>	FutureMonadThrow.handleErrorWith(Kind<Future<?>,A> value, Function1<? super Throwable,? extends Kind<Future<?>,? extends A>> handler)
default <A> Kind<Option<?>,A>	OptionMonadError.handleErrorWith(Kind<Option<?>,A> value, Function1<? super Unit,? extends Kind<Option<?>,? extends A>> handler)
default <A> Kind<Try<?>,A>	TryMonadError.handleErrorWith(Kind<Try<?>,A> value, Function1<? super Throwable,? extends Kind<Try<?>,? extends A>> handler)
default <A, B> Kind<Const<T,?>,B>	ConstFunctor.map(Kind<Const<T,?>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> Kind<Future<?>,R>	FutureFunctor.map(Kind<Future<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Id<?>,R>	IdFunctor.map(Kind<Id<?>,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Kind<IO<?>,R>	IOFunctor.map(Kind<IO<?>,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Kind<Option<?>,R>	OptionFunctor.map(Kind<Option<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Producer<?>,R>	ProducerFunctor.map(Kind<Producer<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Promise<?>,R>	PromiseFunctor.map(Kind<Promise<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Sequence<?>,R>	SequenceFunctor.map(Kind<Sequence<?>,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Kind<Trampoline<?>,R>	TrampolineFunctor.map(Kind<Trampoline<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Try<?>,R>	TryFunctor.map(Kind<Try<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Tuple1<?>,R>	Tuple1Functor.map(Kind<Tuple1<?>,? extends T> value, Function1<? super T,? extends R> map)
default <A, B> Kind<Option<?>,Tuple2<A,B>>	OptionSemigroupal.product(Kind<Option<?>,? extends A> fa, Kind<Option<?>,? extends B> fb)
default <T> Kind<Eval<?>,T>	EvalPure.pure(T value)
default <T> Kind<Future<?>,T>	FuturePure.pure(T value)
default <T> Kind<Id<?>,T>	IdPure.pure(T value)
default <T> Kind<Option<?>,T>	OptionPure.pure(T value)
default <T> Kind<Producer<?>,T>	ProducerPure.pure(T value)
default <T> Kind<Promise<?>,T>	PromisePure.pure(T value)
default <T> Kind<Sequence<?>,T>	SequencePure.pure(T value)
default <T> Kind<Trampoline<?>,T>	TrampolinePure.pure(T value)
default <T> Kind<Try<?>,T>	TryPure.pure(T value)
default <A> Kind<Eval<?>,A>	EvalMonadError.raiseError(Throwable error)
default <A> Kind<Future<?>,A>	FutureMonadThrow.raiseError(Throwable error)
default <A> Kind<Option<?>,A>	OptionMonadError.raiseError(Unit error)
default <A> Kind<Try<?>,A>	TryMonadError.raiseError(Throwable error)
Kind<F,Either<E,A>>	MonadMTL.EffectE.run()
default <T, R> Kind<Either<L,?>,R>	EitherMonad.tailRecM(T value, Function1<T,? extends Kind<Either<L,?>,Either<T,R>>> map)
default <T, R> Kind<Option<?>,R>	OptionMonad.tailRecM(T value, Function1<T,? extends Kind<Option<?>,Either<T,R>>> map)
default <T, R> Kind<Try<?>,R>	TryMonad.tailRecM(T value, Function1<T,? extends Kind<Try<?>,Either<T,R>>> map)
default <T, R> Kind<Validation<E,?>,R>	ValidationMonad.tailRecM(T value, Function1<T,? extends Kind<Validation<E,?>,Either<T,R>>> map)
default <G extends Kind<G, ?>, A, B> Kind<G,Kind<Const<T,?>,B>>	ConstTraverse.traverse(Applicative<G> applicative, Kind<Const<T,?>,A> value, Function1<? super A,? extends Kind<G,? extends B>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Either<L,?>,R>>	EitherTraverse.traverse(Applicative<G> applicative, Kind<Either<L,?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Id<?>,R>>	IdTraverse.traverse(Applicative<G> applicative, Kind<Id<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Option<?>,R>>	OptionTraverse.traverse(Applicative<G> applicative, Kind<Option<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Sequence<?>,R>>	SequenceTraverse.traverse(Applicative<G> applicative, Kind<Sequence<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Try<?>,R>>	TryTraverse.traverse(Applicative<G> applicative, Kind<Try<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <T> Kind<Option<?>,T>	OptionMonoidK.zero()
default <T> Kind<Sequence<?>,T>	SequenceMonoidK.zero()

Methods in com.github.tonivade.purefun.instances that return types with arguments of type Kind

Modifier and Type	Method	Description
static <T, A> Eq<Kind<Const<T,?>,A>>	ConstInstances.eq(Eq<T> eq)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> Eq<Kind<EitherK<F,G,?>,T>>	EitherKInstances.eq(Eq<Kind<F,T>> leftEq, Eq<Kind<G,T>> rightEq)
static <F extends Kind<F, ?>, L, R> Eq<Kind<EitherT<F,L,?>,R>>	EitherTInstances.eq(Eq<Kind<F,Either<L,R>>> eq)
static <T> Eq<Kind<Id<?>,T>>	IdInstances.eq(Eq<T> idEq)
static <T> Eq<Kind<Option<?>,T>>	OptionInstances.eq(Eq<T> eqSome)
static <F extends Kind<F, ?>, T> Eq<Kind<OptionT<F,?>,T>>	OptionTInstances.eq(Eq<Kind<F,Option<T>>> eq)
static <T> Eq<Kind<Sequence<?>,T>>	SequenceInstances.eq(Eq<T> eqElement)
static <T> Eq<Kind<Try<?>,T>>	TryInstances.eq(Eq<T> eqSuccess)
static <E, T> Eq<Kind<Validation<E,?>,T>>	ValidationInstances.eq(Eq<E> errorEq, Eq<T> validEq)
private <T, R> Trampoline<Kind<Either<L,?>,R>>	EitherMonad.loop(T value, Function1<T,? extends Kind<Either<L,?>,Either<T,R>>> map)
private <T, R> Trampoline<Kind<Option<?>,R>>	OptionMonad.loop(T value, Function1<T,? extends Kind<Option<?>,Either<T,R>>> map)
private <T, R> Trampoline<Kind<Try<?>,R>>	TryMonad.loop(T value, Function1<T,? extends Kind<Try<?>,Either<T,R>>> map)
private <T, R> Trampoline<Kind<Validation<E,?>,R>>	ValidationMonad.loop(T value, Function1<T,? extends Kind<Validation<E,?>,Either<T,R>>> map)
default <G extends Kind<G, ?>, A, B> Kind<G,Kind<Const<T,?>,B>>	ConstTraverse.traverse(Applicative<G> applicative, Kind<Const<T,?>,A> value, Function1<? super A,? extends Kind<G,? extends B>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Either<L,?>,R>>	EitherTraverse.traverse(Applicative<G> applicative, Kind<Either<L,?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Id<?>,R>>	IdTraverse.traverse(Applicative<G> applicative, Kind<Id<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Option<?>,R>>	OptionTraverse.traverse(Applicative<G> applicative, Kind<Option<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Sequence<?>,R>>	SequenceTraverse.traverse(Applicative<G> applicative, Kind<Sequence<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Try<?>,R>>	TryTraverse.traverse(Applicative<G> applicative, Kind<Try<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)

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

Modifier and Type	Method	Description
default <A, B> Const<T,B>	ConstApplicative.ap(Kind<Const<T,?>,? extends A> value, Kind<Const<T,?>,? extends Function1<? super A,? extends B>> apply)
default <A, B> EIO<E,B>	EIOApplicative.ap(Kind<EIO<E,?>,? extends A> value, Kind<EIO<E,?>,? extends Function1<? super A,? extends B>> apply)
default <T, R> Either<L,R>	EitherApplicative.ap(Kind<Either<L,?>,? extends T> value, Kind<Either<L,?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Eval<?>,R>	EvalApplicative.ap(Kind<Eval<?>,? extends T> value, Kind<Eval<?>,? extends Function1<? super T,? extends R>> apply)
default <A, R> Function1<T,R>	Function1Applicative.ap(Kind<Function1<T,?>,? extends A> value, Kind<Function1<T,?>,? extends Function1<? super A,? extends R>> apply)
default <T, R> Kind<Future<?>,R>	FutureApplicative.ap(Kind<Future<?>,? extends T> value, Kind<Future<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Future<?>,R>	FutureMonad.ap(Kind<Future<?>,? extends T> value, Kind<Future<?>,? extends Function1<? super T,? extends R>> apply)	XXX In order to create real parallel computations, we need to override ap to use the applicative version of the ap method
default <T, R> Kind<Id<?>,R>	IdApplicative.ap(Kind<Id<?>,? extends T> value, Kind<Id<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> IO<R>	IOApplicative.ap(Kind<IO<?>,? extends T> value, Kind<IO<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Option<?>,R>	OptionApplicative.ap(Kind<Option<?>,? extends T> value, Kind<Option<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Producer<?>,R>	ProducerApplicative.ap(Kind<Producer<?>,? extends T> value, Kind<Producer<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Promise<?>,R>	PromiseApplicative.ap(Kind<Promise<?>,? extends T> value, Kind<Promise<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Promise<?>,R>	PromiseMonad.ap(Kind<Promise<?>,? extends T> value, Kind<Promise<?>,? extends Function1<? super T,? extends R>> apply)	XXX In order to create real parallel computations, we need to override ap to use the applicative version of the ap method
default <A, B> PureIO<R,E,B>	PureIOApplicative.ap(Kind<PureIO<R,E,?>,? extends A> value, Kind<PureIO<R,E,?>,? extends Function1<? super A,? extends B>> apply)
default <A, B> RIO<R,B>	RIOApplicative.ap(Kind<RIO<R,?>,? extends A> value, Kind<RIO<R,?>,? extends Function1<? super A,? extends B>> apply)
default <T, R> Kind<Sequence<?>,R>	SequenceApplicative.ap(Kind<Sequence<?>,? extends T> value, Kind<Sequence<?>,? extends Function1<? super T,? extends R>> apply)
default <A, B> Task<B>	TaskApplicative.ap(Kind<Task<?>,? extends A> value, Kind<Task<?>,? extends Function1<? super A,? extends B>> apply)
default <T, R> Kind<Trampoline<?>,R>	TrampolineApplicative.ap(Kind<Trampoline<?>,? extends T> value, Kind<Trampoline<?>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Try<?>,R>	TryApplicative.ap(Kind<Try<?>,? extends T> value, Kind<Try<?>,? extends Function1<? super T,? extends R>> apply)
default <A, B> UIO<B>	UIOApplicative.ap(Kind<UIO<?>,? extends A> value, Kind<UIO<?>,? extends Function1<? super A,? extends B>> apply)
default <A, B> URIO<R,B>	URIOApplicative.ap(Kind<URIO<R,?>,? extends A> value, Kind<URIO<R,?>,? extends Function1<? super A,? extends B>> apply)
default <T, R> Validation<E,R>	ValidationApplicative.ap(Kind<Validation<E,?>,? extends T> value, Kind<Validation<E,?>,? extends Function1<? super T,? extends R>> apply)
default <A, B> EIO<E,B>	EIOBracket.bracket(Kind<EIO<E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> use, Function1<? super A,? extends Kind<EIO<E,?>,Unit>> release)
default <A, B> EitherT<F,E,B>	EitherTBracket.bracket(Kind<EitherT<F,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EitherT<F,E,?>,? extends B>> use, Function1<? super A,? extends Kind<EitherT<F,E,?>,Unit>> release)
default <A, B> IO<B>	IOBracket.bracket(Kind<IO<?>,? extends A> acquire, Function1<? super A,? extends Kind<IO<?>,? extends B>> use, Function1<? super A,? extends Kind<IO<?>,Unit>> release)
default <A, B> OptionT<F,B>	OptionTBracket.bracket(Kind<OptionT<F,?>,? extends A> acquire, Function1<? super A,? extends Kind<OptionT<F,?>,? extends B>> use, Function1<? super A,? extends Kind<OptionT<F,?>,Unit>> release)
default <A, B> PureIO<R,E,B>	PureIOBracket.bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use, Function1<? super A,? extends Kind<PureIO<R,E,?>,Unit>> release)
default <A, B> RIO<R,B>	RIOBracket.bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use, Function1<? super A,? extends Kind<RIO<R,?>,Unit>> release)
default <A, B> Task<B>	TaskBracket.bracket(Kind<Task<?>,? extends A> acquire, Function1<? super A,? extends Kind<Task<?>,? extends B>> use, Function1<? super A,? extends Kind<Task<?>,Unit>> release)
default <A, B> UIO<B>	UIOBracket.bracket(Kind<UIO<?>,? extends A> acquire, Function1<? super A,? extends Kind<UIO<?>,? extends B>> use, Function1<? super A,? extends Kind<UIO<?>,Unit>> release)
default <A, B> URIO<R,B>	URIOBracket.bracket(Kind<URIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> use, Function1<? super A,? extends Kind<URIO<R,?>,Unit>> release)
default <A, B> EitherK<F,G,B>	EitherKComonad.coflatMap(Kind<EitherK<F,G,?>,? extends A> value, Function1<? super Kind<EitherK<F,G,?>,? extends A>,? extends B> map)
default <A, B> Kind<Eval<?>,B>	EvalComonad.coflatMap(Kind<Eval<?>,? extends A> value, Function1<? super Kind<Eval<?>,? extends A>,? extends B> map)
default <A, B> Kind<Id<?>,B>	IdComonad.coflatMap(Kind<Id<?>,? extends A> value, Function1<? super Kind<Id<?>,? extends A>,? extends B> map)
default <A, B> Kind<Producer<?>,B>	ProducerComonad.coflatMap(Kind<Producer<?>,? extends A> value, Function1<? super Kind<Producer<?>,? extends A>,? extends B> map)
default <T> Kind<Option<?>,T>	OptionSemigroupK.combineK(Kind<Option<?>,? extends T> t1, Kind<Option<?>,? extends T> t2)
default <T> Kind<Sequence<?>,T>	SequenceSemigroupK.combineK(Kind<Sequence<?>,? extends T> t1, Kind<Sequence<?>,? extends T> t2)
default <A, B> Const<T,B>	ConstContravariant.contramap(Kind<Const<T,?>,? extends A> value, Function1<? super B,? extends A> map)
default <A, B> EitherK<F,G,B>	EitherKContravariant.contramap(Kind<EitherK<F,G,?>,? extends A> value, Function1<? super B,? extends A> map)
<A> MonadMTL.EffectS<F,S,R,E,A>	MonadMTL.effect(Kind<F,Either<E,A>> value)
<A> MonadMTL.EffectE<F,E,A>	MonadMTL.effectE(Kind<F,Either<E,A>> value)
default <A> A	EitherKComonad.extract(Kind<EitherK<F,G,?>,? extends A> value)
default <A> A	EvalComonad.extract(Kind<Eval<?>,? extends A> value)
default <A> A	IdComonad.extract(Kind<Id<?>,? extends A> value)
default <A> A	ProducerComonad.extract(Kind<Producer<?>,? extends A> value)
<A, B> MonadMTL.EffectE<F,E,B>	EffectEMonadError.flatMap(Kind<MonadMTL.EffectE<F,E,?>,? extends A> value, Function1<? super A,? extends Kind<MonadMTL.EffectE<F,E,?>,? extends B>> map)
<A, B> MonadMTL.EffectR<F,R,E,B>	EffectRMonad.flatMap(Kind<MonadMTL.EffectR<F,R,E,?>,? extends A> value, Function1<? super A,? extends Kind<MonadMTL.EffectR<F,R,E,?>,? extends B>> map)
default <A, B> EIO<E,B>	EIOMonad.flatMap(Kind<EIO<E,?>,? extends A> value, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> map)
default <T, R> Either<L,R>	EitherMonad.flatMap(Kind<Either<L,?>,? extends T> value, Function1<? super T,? extends Kind<Either<L,?>,? extends R>> map)
default <T, R> EitherT<F,L,R>	EitherTMonad.flatMap(Kind<EitherT<F,L,?>,? extends T> value, Function1<? super T,? extends Kind<EitherT<F,L,?>,? extends R>> map)
default <T, R> Kind<Eval<?>,R>	EvalMonad.flatMap(Kind<Eval<?>,? extends T> value, Function1<? super T,? extends Kind<Eval<?>,? extends R>> map)
default <A, R> Function1<T,R>	Function1Monad.flatMap(Kind<Function1<T,?>,? extends A> value, Function1<? super A,? extends Kind<Function1<T,?>,? extends R>> map)
default <T, R> Kind<Future<?>,R>	FutureMonad.flatMap(Kind<Future<?>,? extends T> value, Function1<? super T,? extends Kind<Future<?>,? extends R>> map)
default <T, R> Kind<Id<?>,R>	IdMonad.flatMap(Kind<Id<?>,? extends T> value, Function1<? super T,? extends Kind<Id<?>,? extends R>> map)
default <T, R> IO<R>	IOMonad.flatMap(Kind<IO<?>,? extends T> value, Function1<? super T,? extends Kind<IO<?>,? extends R>> map)
default <T, R> Kleisli<F,Z,R>	KleisliMonad.flatMap(Kind<Kleisli<F,Z,?>,? extends T> value, Function1<? super T,? extends Kind<Kleisli<F,Z,?>,? extends R>> map)
<A, B> MonadMTL.EffectS<F,S,R,E,B>	MonadMTL.flatMap(Kind<MonadMTL.EffectS<F,S,R,E,?>,? extends A> value, Function1<? super A,? extends Kind<MonadMTL.EffectS<F,S,R,E,?>,? extends B>> map)
default <T, R> Kind<Option<?>,R>	OptionMonad.flatMap(Kind<Option<?>,? extends T> value, Function1<? super T,? extends Kind<Option<?>,? extends R>> map)
default <T, R> OptionT<F,R>	OptionTMonad.flatMap(Kind<OptionT<F,?>,? extends T> value, Function1<? super T,? extends Kind<OptionT<F,?>,? extends R>> map)
default <T, R> Kind<Producer<?>,R>	ProducerMonad.flatMap(Kind<Producer<?>,? extends T> value, Function1<? super T,? extends Kind<Producer<?>,? extends R>> mapper)
default <T, R> Kind<Promise<?>,R>	PromiseMonad.flatMap(Kind<Promise<?>,? extends T> value, Function1<? super T,? extends Kind<Promise<?>,? extends R>> map)
default <A, B> PureIO<R,E,B>	PureIOMonad.flatMap(Kind<PureIO<R,E,?>,? extends A> value, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> map)
default <T, R> PureStream<F,R>	PureStreamMonad.flatMap(Kind<PureStream<F,?>,? extends T> value, Function1<? super T,? extends Kind<PureStream<F,?>,? extends R>> mapper)
default <T, V> Reader<R,V>	ReaderMonad.flatMap(Kind<Reader<R,?>,? extends T> value, Function1<? super T,? extends Kind<Reader<R,?>,? extends V>> map)
default <A, B> RIO<R,B>	RIOMonad.flatMap(Kind<RIO<R,?>,? extends A> value, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> map)
default <T, R> Kind<Sequence<?>,R>	SequenceMonad.flatMap(Kind<Sequence<?>,? extends T> value, Function1<? super T,? extends Kind<Sequence<?>,? extends R>> map)
default <T, R> State<S,R>	StateMonad.flatMap(Kind<State<S,?>,? extends T> value, Function1<? super T,? extends Kind<State<S,?>,? extends R>> map)
default <T, R> StateT<F,S,R>	StateTMonad.flatMap(Kind<StateT<F,S,?>,? extends T> value, Function1<? super T,? extends Kind<StateT<F,S,?>,? extends R>> map)
default <A, B> Task<B>	TaskMonad.flatMap(Kind<Task<?>,? extends A> value, Function1<? super A,? extends Kind<Task<?>,? extends B>> map)
default <T, R> Kind<Trampoline<?>,R>	TrampolineMonad.flatMap(Kind<Trampoline<?>,? extends T> value, Function1<? super T,? extends Kind<Trampoline<?>,? extends R>> map)
default <T, R> Kind<Try<?>,R>	TryMonad.flatMap(Kind<Try<?>,? extends T> value, Function1<? super T,? extends Kind<Try<?>,? extends R>> map)
default <A, B> UIO<B>	UIOMonad.flatMap(Kind<UIO<?>,? extends A> value, Function1<? super A,? extends Kind<UIO<?>,? extends B>> map)
default <A, B> URIO<R,B>	URIOMonad.flatMap(Kind<URIO<R,?>,? extends A> value, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> map)
default <T, R> Validation<E,R>	ValidationMonad.flatMap(Kind<Validation<E,?>,? extends T> value, Function1<? super T,? extends Kind<Validation<E,?>,? extends R>> map)
default <T, R> Writer<L,R>	WriterMonad.flatMap(Kind<Writer<L,?>,? extends T> value, Function1<? super T,? extends Kind<Writer<L,?>,? extends R>> map)
default <T, R> WriterT<F,L,R>	WriterTMonad.flatMap(Kind<WriterT<F,L,?>,? extends T> value, Function1<? super T,? extends Kind<WriterT<F,L,?>,? extends R>> map)
default <A, B> B	ConstFoldable.foldLeft(Kind<Const<T,?>,? extends A> value, B initial, Function2<? super B,? super A,? extends B> mapper)
default <A, B> B	EitherFoldable.foldLeft(Kind<Either<L,?>,? extends A> value, B initial, Function2<? super B,? super A,? extends B> mapper)
default <A, B> B	IdFoldable.foldLeft(Kind<Id<?>,? extends A> value, B initial, Function2<? super B,? super A,? extends B> mapper)
default <A, B> B	OptionFoldable.foldLeft(Kind<Option<?>,? extends A> value, B initial, Function2<? super B,? super A,? extends B> mapper)
default <A, B> B	SequenceFoldable.foldLeft(Kind<Sequence<?>,? extends A> value, B initial, Function2<? super B,? super A,? extends B> mapper)
default <A, B> B	TryFoldable.foldLeft(Kind<Try<?>,? extends A> value, B initial, Function2<? super B,? super A,? extends B> mapper)
default <A, B> Eval<B>	ConstFoldable.foldRight(Kind<Const<T,?>,? extends A> value, Eval<? extends B> initial, Function2<? super A,? super Eval<? extends B>,? extends Eval<? extends B>> mapper)
default <A, B> Eval<B>	EitherFoldable.foldRight(Kind<Either<L,?>,? extends A> value, Eval<? extends B> initial, Function2<? super A,? super Eval<? extends B>,? extends Eval<? extends B>> mapper)
default <A, B> Eval<B>	IdFoldable.foldRight(Kind<Id<?>,? extends A> value, Eval<? extends B> initial, Function2<? super A,? super Eval<? extends B>,? extends Eval<? extends B>> mapper)
default <A, B> Eval<B>	OptionFoldable.foldRight(Kind<Option<?>,? extends A> value, Eval<? extends B> initial, Function2<? super A,? super Eval<? extends B>,? extends Eval<? extends B>> mapper)
default <A, B> Eval<B>	SequenceFoldable.foldRight(Kind<Sequence<?>,? extends A> value, Eval<? extends B> initial, Function2<? super A,? super Eval<? extends B>,? extends Eval<? extends B>> mapper)
default <A, B> Eval<B>	TryFoldable.foldRight(Kind<Try<?>,? extends A> value, Eval<? extends B> initial, Function2<? super A,? super Eval<? extends B>,? extends Eval<? extends B>> mapper)
default <A> EIO<Throwable,Fiber<EIO<Throwable,?>,A>>	EIOConcurrent.fork(Kind<EIO<Throwable,?>,? extends A> value)
default <A> IO<Fiber<IO<?>,A>>	IOConcurrent.fork(Kind<IO<?>,? extends A> value)
default <A> PureIO<R,Throwable,Fiber<PureIO<R,Throwable,?>,A>>	PureIOConcurrent.fork(Kind<PureIO<R,Throwable,?>,? extends A> value)
default <A> RIO<R,Fiber<RIO<R,?>,A>>	RIOConcurrent.fork(Kind<RIO<R,?>,? extends A> value)
default <A> Task<Fiber<Task<?>,A>>	TaskConcurrent.fork(Kind<Task<?>,? extends A> value)
default <A> UIO<Fiber<UIO<?>,A>>	UIOConcurrent.fork(Kind<UIO<?>,? extends A> value)
default <A> URIO<R,Fiber<URIO<R,?>,A>>	URIOConcurrent.fork(Kind<URIO<R,?>,? extends A> value)
<A> MonadMTL.EffectE<F,E,A>	EffectEMonadError.handleErrorWith(Kind<MonadMTL.EffectE<F,E,?>,A> value, Function1<? super E,? extends Kind<MonadMTL.EffectE<F,E,?>,? extends A>> handler)
<A> MonadMTL.EffectR<F,R,E,A>	EffectRMonadError.handleErrorWith(Kind<MonadMTL.EffectR<F,R,E,?>,A> value, Function1<? super E,? extends Kind<MonadMTL.EffectR<F,R,E,?>,? extends A>> handler)
default <A> EIO<E,A>	EIOMonadError.handleErrorWith(Kind<EIO<E,?>,A> value, Function1<? super E,? extends Kind<EIO<E,?>,? extends A>> handler)
default <A> Either<L,A>	EitherMonadError.handleErrorWith(Kind<Either<L,?>,A> value, Function1<? super L,? extends Kind<Either<L,?>,? extends A>> handler)
default <A> EitherT<F,E,A>	EitherTMonadErrorFromMonad.handleErrorWith(Kind<EitherT<F,E,?>,A> value, Function1<? super E,? extends Kind<EitherT<F,E,?>,? extends A>> handler)
default <A> EitherT<F,E,A>	EitherTMonadErrorFromMonadError.handleErrorWith(Kind<EitherT<F,E,?>,A> value, Function1<? super E,? extends Kind<EitherT<F,E,?>,? extends A>> handler)
default <A> Kind<Eval<?>,A>	EvalMonadError.handleErrorWith(Kind<Eval<?>,A> value, Function1<? super Throwable,? extends Kind<Eval<?>,? extends A>> handler)
default <A> Kind<Future<?>,A>	FutureMonadThrow.handleErrorWith(Kind<Future<?>,A> value, Function1<? super Throwable,? extends Kind<Future<?>,? extends A>> handler)
default <A> IO<A>	IOMonadError.handleErrorWith(Kind<IO<?>,A> value, Function1<? super Throwable,? extends Kind<IO<?>,? extends A>> handler)
default <A> Kleisli<F,R,A>	KleisliMonadError.handleErrorWith(Kind<Kleisli<F,R,?>,A> value, Function1<? super E,? extends Kind<Kleisli<F,R,?>,? extends A>> handler)
<A> MonadMTL.EffectS<F,S,R,E,A>	MonadMTL.handleErrorWith(Kind<MonadMTL.EffectS<F,S,R,E,?>,A> value, Function1<? super E,? extends Kind<MonadMTL.EffectS<F,S,R,E,?>,? extends A>> handler)
default <A> Kind<Option<?>,A>	OptionMonadError.handleErrorWith(Kind<Option<?>,A> value, Function1<? super Unit,? extends Kind<Option<?>,? extends A>> handler)
default <A> OptionT<F,A>	OptionTMonadErrorFromMonad.handleErrorWith(Kind<OptionT<F,?>,A> value, Function1<? super Unit,? extends Kind<OptionT<F,?>,? extends A>> handler)
default <A> OptionT<F,A>	OptionTMonadErrorFromMonadError.handleErrorWith(Kind<OptionT<F,?>,A> value, Function1<? super E,? extends Kind<OptionT<F,?>,? extends A>> handler)
default <A> PureIO<R,E,A>	PureIOMonadError.handleErrorWith(Kind<PureIO<R,E,?>,A> value, Function1<? super E,? extends Kind<PureIO<R,E,?>,? extends A>> handler)
default <A> RIO<R,A>	RIOMonadError.handleErrorWith(Kind<RIO<R,?>,A> value, Function1<? super Throwable,? extends Kind<RIO<R,?>,? extends A>> handler)
default <A> StateT<F,S,A>	StateTMonadError.handleErrorWith(Kind<StateT<F,S,?>,A> value, Function1<? super E,? extends Kind<StateT<F,S,?>,? extends A>> handler)
default <A> Task<A>	TaskMonadError.handleErrorWith(Kind<Task<?>,A> value, Function1<? super Throwable,? extends Kind<Task<?>,? extends A>> handler)
default <A> Kind<Try<?>,A>	TryMonadError.handleErrorWith(Kind<Try<?>,A> value, Function1<? super Throwable,? extends Kind<Try<?>,? extends A>> handler)
default <A> UIO<A>	UIOMonadError.handleErrorWith(Kind<UIO<?>,A> value, Function1<? super Throwable,? extends Kind<UIO<?>,? extends A>> handler)
default <A> URIO<R,A>	URIOMonadError.handleErrorWith(Kind<URIO<R,?>,A> value, Function1<? super Throwable,? extends Kind<URIO<R,?>,? extends A>> handler)
default <A> Validation<E,A>	ValidationMonadError.handleErrorWith(Kind<Validation<E,?>,A> value, Function1<? super E,? extends Kind<Validation<E,?>,? extends A>> handler)
default <A> WriterT<F,L,A>	WriterTMonadError.handleErrorWith(Kind<WriterT<F,L,?>,A> value, Function1<? super E,? extends Kind<WriterT<F,L,?>,? extends A>> handler)
default <T> EitherK<F,G,T>	EitherKInjectKLeft.inject(Kind<F,? extends T> value)
default <T> EitherK<G,R,T>	EitherKInjectKRight.inject(Kind<F,? extends T> value)
default <A> WriterT<F,L,Tuple2<L,A>>	WriterTMonadWriter.listen(Kind<WriterT<F,L,?>,? extends A> value)
default <A, B> Kind<Const<T,?>,B>	ConstFunctor.map(Kind<Const<T,?>,? extends A> value, Function1<? super A,? extends B> map)
default <A, B> EIO<E,B>	EIOFunctor.map(Kind<EIO<E,?>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> Either<L,R>	EitherFunctor.map(Kind<Either<L,?>,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> EitherK<F,G,R>	EitherKFunctor.map(Kind<EitherK<F,G,?>,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Eval<R>	EvalFunctor.map(Kind<Eval<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <A, R> Function1<T,R>	Function1Functor.map(Kind<Function1<T,?>,? extends A> value, Function1<? super A,? extends R> map)
default <T, R> Kind<Future<?>,R>	FutureFunctor.map(Kind<Future<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Id<?>,R>	IdFunctor.map(Kind<Id<?>,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Kind<IO<?>,R>	IOFunctor.map(Kind<IO<?>,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Kind<Option<?>,R>	OptionFunctor.map(Kind<Option<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Producer<?>,R>	ProducerFunctor.map(Kind<Producer<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Promise<?>,R>	PromiseFunctor.map(Kind<Promise<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <A, B> PureIO<R,E,B>	PureIOFunctor.map(Kind<PureIO<R,E,?>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> PureStream<F,R>	PureStreamFunctor.map(Kind<PureStream<F,?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <A, B> RIO<R,B>	RIOFunctor.map(Kind<RIO<R,?>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> Schedule<F,A,R>	ScheduleFunctor.map(Kind<Schedule<F,A,?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Sequence<?>,R>	SequenceFunctor.map(Kind<Sequence<?>,? extends T> value, Function1<? super T,? extends R> map)
default <A, B> Task<B>	TaskFunctor.map(Kind<Task<?>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> Kind<Trampoline<?>,R>	TrampolineFunctor.map(Kind<Trampoline<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Try<?>,R>	TryFunctor.map(Kind<Try<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Tuple1<?>,R>	Tuple1Functor.map(Kind<Tuple1<?>,? extends T> value, Function1<? super T,? extends R> map)
default <A, B> UIO<B>	UIOFunctor.map(Kind<UIO<?>,? extends A> value, Function1<? super A,? extends B> map)
default <A, B> URIO<R,B>	URIOFunctor.map(Kind<URIO<R,?>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> Validation<E,R>	ValidationFunctor.map(Kind<Validation<E,?>,? extends T> value, Function1<? super T,? extends R> map)
default <T> Future<T>	EIORuntime.parRun(Kind<EIO<E,?>,T> value, Executor executor)
default <T> Future<T>	IORuntime.parRun(Kind<IO<?>,T> value, Executor executor)
default <T> Future<T>	PureIORuntime.parRun(Kind<PureIO<R,E,?>,T> value, Executor executor)
default <T> Future<T>	RIORuntime.parRun(Kind<RIO<R,?>,T> value, Executor executor)
default <T> Future<T>	TaskRuntime.parRun(Kind<Task<?>,T> value, Executor executor)
default <T> Future<T>	UIORuntime.parRun(Kind<UIO<?>,T> value, Executor executor)
default <T> Future<T>	URIORuntime.parRun(Kind<URIO<R,?>,T> value, Executor executor)
default <A> WriterT<F,L,A>	WriterTMonadWriter.pass(Kind<WriterT<F,L,?>,Tuple2<Operator1<L>,A>> value)
default <A, B> Kind<Option<?>,Tuple2<A,B>>	OptionSemigroupal.product(Kind<Option<?>,? extends A> fa, Kind<Option<?>,? extends B> fb)
default <A, B> EIO<Throwable,Either<Tuple2<A,Fiber<EIO<Throwable,?>,B>>,Tuple2<Fiber<EIO<Throwable,?>,A>,B>>>	EIOConcurrent.racePair(Kind<EIO<Throwable,?>,? extends A> fa, Kind<EIO<Throwable,?>,? extends B> fb)
default <A, B> IO<Either<Tuple2<A,Fiber<IO<?>,B>>,Tuple2<Fiber<IO<?>,A>,B>>>	IOConcurrent.racePair(Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
default <A, B> PureIO<R,Throwable,Either<Tuple2<A,Fiber<PureIO<R,Throwable,?>,B>>,Tuple2<Fiber<PureIO<R,Throwable,?>,A>,B>>>	PureIOConcurrent.racePair(Kind<PureIO<R,Throwable,?>,? extends A> fa, Kind<PureIO<R,Throwable,?>,? extends B> fb)
default <A, B> RIO<R,Either<Tuple2<A,Fiber<RIO<R,?>,B>>,Tuple2<Fiber<RIO<R,?>,A>,B>>>	RIOConcurrent.racePair(Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
default <A, B> Task<Either<Tuple2<A,Fiber<Task<?>,B>>,Tuple2<Fiber<Task<?>,A>,B>>>	TaskConcurrent.racePair(Kind<Task<?>,? extends A> fa, Kind<Task<?>,? extends B> fb)
default <A, B> UIO<Either<Tuple2<A,Fiber<UIO<?>,B>>,Tuple2<Fiber<UIO<?>,A>,B>>>	UIOConcurrent.racePair(Kind<UIO<?>,? extends A> fa, Kind<UIO<?>,? extends B> fb)
default <A, B> URIO<R,Either<Tuple2<A,Fiber<URIO<R,?>,B>>,Tuple2<Fiber<URIO<R,?>,A>,B>>>	URIOConcurrent.racePair(Kind<URIO<R,?>,? extends A> fa, Kind<URIO<R,?>,? extends B> fb)
default <T> T	EIORuntime.run(Kind<EIO<E,?>,T> value)
default <T> T	IORuntime.run(Kind<IO<?>,T> value)
default <T> T	PureIORuntime.run(Kind<PureIO<R,E,?>,T> value)
default <T> T	RIORuntime.run(Kind<RIO<R,?>,T> value)
default <T> T	TaskRuntime.run(Kind<Task<?>,T> value)
default <T> T	UIORuntime.run(Kind<UIO<?>,T> value)
default <T> T	URIORuntime.run(Kind<URIO<R,?>,T> value)
default <A, B> Validation<E,B>	ValidationSelective.select(Kind<Validation<E,?>,Either<A,B>> value, Kind<Validation<E,?>,Function1<? super A,? extends B>> apply)
static <F extends Kind<F, ?>, E, A> MonadMTL.EffectE<F,E,A>	MonadMTL.EffectE.toEffectE(Kind<MonadMTL.EffectE<F,E,?>,? extends A> hkt)
static <F extends Kind<F, ?>, R, E, A> MonadMTL.EffectR<F,R,E,A>	MonadMTL.EffectR.toEffectR(Kind<MonadMTL.EffectR<F,R,E,?>,? extends A> hkt)
static <F extends Kind<F, ?>, S, R, E, A> MonadMTL.EffectS<F,S,R,E,A>	MonadMTL.EffectS.toEffectS(Kind<MonadMTL.EffectS<F,S,R,E,?>,? extends A> hkt)
default <G extends Kind<G, ?>, A, B> Kind<G,Kind<Const<T,?>,B>>	ConstTraverse.traverse(Applicative<G> applicative, Kind<Const<T,?>,A> value, Function1<? super A,? extends Kind<G,? extends B>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Either<L,?>,R>>	EitherTraverse.traverse(Applicative<G> applicative, Kind<Either<L,?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Id<?>,R>>	IdTraverse.traverse(Applicative<G> applicative, Kind<Id<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Option<?>,R>>	OptionTraverse.traverse(Applicative<G> applicative, Kind<Option<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Sequence<?>,R>>	SequenceTraverse.traverse(Applicative<G> applicative, Kind<Sequence<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Try<?>,R>>	TryTraverse.traverse(Applicative<G> applicative, Kind<Try<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)

Method parameters in com.github.tonivade.purefun.instances with type arguments of type Kind

Modifier and Type	Method	Description
default <A> EIO<Throwable,A>	EIOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<EIO<Throwable,?>,Unit>> consumer)
default <A> IO<A>	IOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<IO<?>,Unit>> consumer)
default <A> PureIO<R,Throwable,A>	PureIOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<PureIO<R,Throwable,?>,Unit>> consumer)
default <A> RIO<R,A>	RIOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<RIO<R,?>,Unit>> consumer)
default <A> Task<A>	TaskAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<Task<?>,Unit>> consumer)
default <A> UIO<A>	UIOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<UIO<?>,Unit>> consumer)
default <A> URIO<R,A>	URIOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<URIO<R,?>,Unit>> consumer)
default <A, B> EIO<E,B>	EIOBracket.bracket(Kind<EIO<E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> use, Function1<? super A,? extends Kind<EIO<E,?>,Unit>> release)
default <A, B> EitherT<F,E,B>	EitherTBracket.bracket(Kind<EitherT<F,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EitherT<F,E,?>,? extends B>> use, Function1<? super A,? extends Kind<EitherT<F,E,?>,Unit>> release)
default <A, B> IO<B>	IOBracket.bracket(Kind<IO<?>,? extends A> acquire, Function1<? super A,? extends Kind<IO<?>,? extends B>> use, Function1<? super A,? extends Kind<IO<?>,Unit>> release)
default <A, B> OptionT<F,B>	OptionTBracket.bracket(Kind<OptionT<F,?>,? extends A> acquire, Function1<? super A,? extends Kind<OptionT<F,?>,? extends B>> use, Function1<? super A,? extends Kind<OptionT<F,?>,Unit>> release)
default <A, B> PureIO<R,E,B>	PureIOBracket.bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use, Function1<? super A,? extends Kind<PureIO<R,E,?>,Unit>> release)
default <A, B> RIO<R,B>	RIOBracket.bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use, Function1<? super A,? extends Kind<RIO<R,?>,Unit>> release)
default <A, B> Task<B>	TaskBracket.bracket(Kind<Task<?>,? extends A> acquire, Function1<? super A,? extends Kind<Task<?>,? extends B>> use, Function1<? super A,? extends Kind<Task<?>,Unit>> release)
default <A, B> UIO<B>	UIOBracket.bracket(Kind<UIO<?>,? extends A> acquire, Function1<? super A,? extends Kind<UIO<?>,? extends B>> use, Function1<? super A,? extends Kind<UIO<?>,Unit>> release)
default <A, B> URIO<R,B>	URIOBracket.bracket(Kind<URIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> use, Function1<? super A,? extends Kind<URIO<R,?>,Unit>> release)
default <A, B> EitherK<F,G,B>	EitherKComonad.coflatMap(Kind<EitherK<F,G,?>,? extends A> value, Function1<? super Kind<EitherK<F,G,?>,? extends A>,? extends B> map)
default <A, B> Kind<Eval<?>,B>	EvalComonad.coflatMap(Kind<Eval<?>,? extends A> value, Function1<? super Kind<Eval<?>,? extends A>,? extends B> map)
default <A, B> Kind<Id<?>,B>	IdComonad.coflatMap(Kind<Id<?>,? extends A> value, Function1<? super Kind<Id<?>,? extends A>,? extends B> map)
default <A, B> Kind<Producer<?>,B>	ProducerComonad.coflatMap(Kind<Producer<?>,? extends A> value, Function1<? super Kind<Producer<?>,? extends A>,? extends B> map)
default <A> EIO<E,A>	EIODefer.defer(Producer<? extends Kind<EIO<E,?>,? extends A>> defer)
default <A> EitherT<F,E,A>	EitherTDefer.defer(Producer<? extends Kind<EitherT<F,E,?>,? extends A>> defer)
default <A> Kind<Eval<?>,A>	EvalDefer.defer(Producer<? extends Kind<Eval<?>,? extends A>> defer)
default <A> IO<A>	IODefer.defer(Producer<? extends Kind<IO<?>,? extends A>> defer)
default <A> OptionT<F,A>	OptionTDefer.defer(Producer<? extends Kind<OptionT<F,?>,? extends A>> defer)
default <A> PureIO<R,E,A>	PureIODefer.defer(Producer<? extends Kind<PureIO<R,E,?>,? extends A>> defer)
default <A> RIO<R,A>	RIODefer.defer(Producer<? extends Kind<RIO<R,?>,? extends A>> defer)
default <A> Task<A>	TaskDefer.defer(Producer<? extends Kind<Task<?>,? extends A>> defer)
default <A> Kind<Trampoline<?>,A>	TrampolineDefer.defer(Producer<? extends Kind<Trampoline<?>,? extends A>> defer)
default <A> UIO<A>	UIODefer.defer(Producer<? extends Kind<UIO<?>,? extends A>> defer)
default <A> URIO<R,A>	URIODefer.defer(Producer<? extends Kind<URIO<R,?>,? extends A>> defer)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, T> Eq<Kind<EitherK<F,G,?>,T>>	EitherKInstances.eq(Eq<Kind<F,T>> leftEq, Eq<Kind<G,T>> rightEq)
static <F extends Kind<F, ?>, L, R> Eq<Kind<EitherT<F,L,?>,R>>	EitherTInstances.eq(Eq<Kind<F,Either<L,R>>> eq)
static <F extends Kind<F, ?>, T> Eq<Kind<OptionT<F,?>,T>>	OptionTInstances.eq(Eq<Kind<F,Option<T>>> eq)
<A, B> MonadMTL.EffectE<F,E,B>	EffectEMonadError.flatMap(Kind<MonadMTL.EffectE<F,E,?>,? extends A> value, Function1<? super A,? extends Kind<MonadMTL.EffectE<F,E,?>,? extends B>> map)
<A, B> MonadMTL.EffectR<F,R,E,B>	EffectRMonad.flatMap(Kind<MonadMTL.EffectR<F,R,E,?>,? extends A> value, Function1<? super A,? extends Kind<MonadMTL.EffectR<F,R,E,?>,? extends B>> map)
default <A, B> EIO<E,B>	EIOMonad.flatMap(Kind<EIO<E,?>,? extends A> value, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> map)
default <T, R> Either<L,R>	EitherMonad.flatMap(Kind<Either<L,?>,? extends T> value, Function1<? super T,? extends Kind<Either<L,?>,? extends R>> map)
default <T, R> EitherT<F,L,R>	EitherTMonad.flatMap(Kind<EitherT<F,L,?>,? extends T> value, Function1<? super T,? extends Kind<EitherT<F,L,?>,? extends R>> map)
default <T, R> Kind<Eval<?>,R>	EvalMonad.flatMap(Kind<Eval<?>,? extends T> value, Function1<? super T,? extends Kind<Eval<?>,? extends R>> map)
default <A, R> Function1<T,R>	Function1Monad.flatMap(Kind<Function1<T,?>,? extends A> value, Function1<? super A,? extends Kind<Function1<T,?>,? extends R>> map)
default <T, R> Kind<Future<?>,R>	FutureMonad.flatMap(Kind<Future<?>,? extends T> value, Function1<? super T,? extends Kind<Future<?>,? extends R>> map)
default <T, R> Kind<Id<?>,R>	IdMonad.flatMap(Kind<Id<?>,? extends T> value, Function1<? super T,? extends Kind<Id<?>,? extends R>> map)
default <T, R> IO<R>	IOMonad.flatMap(Kind<IO<?>,? extends T> value, Function1<? super T,? extends Kind<IO<?>,? extends R>> map)
default <T, R> Kleisli<F,Z,R>	KleisliMonad.flatMap(Kind<Kleisli<F,Z,?>,? extends T> value, Function1<? super T,? extends Kind<Kleisli<F,Z,?>,? extends R>> map)
<A, B> MonadMTL.EffectS<F,S,R,E,B>	MonadMTL.flatMap(Kind<MonadMTL.EffectS<F,S,R,E,?>,? extends A> value, Function1<? super A,? extends Kind<MonadMTL.EffectS<F,S,R,E,?>,? extends B>> map)
default <T, R> Kind<Option<?>,R>	OptionMonad.flatMap(Kind<Option<?>,? extends T> value, Function1<? super T,? extends Kind<Option<?>,? extends R>> map)
default <T, R> OptionT<F,R>	OptionTMonad.flatMap(Kind<OptionT<F,?>,? extends T> value, Function1<? super T,? extends Kind<OptionT<F,?>,? extends R>> map)
default <T, R> Kind<Producer<?>,R>	ProducerMonad.flatMap(Kind<Producer<?>,? extends T> value, Function1<? super T,? extends Kind<Producer<?>,? extends R>> mapper)
default <T, R> Kind<Promise<?>,R>	PromiseMonad.flatMap(Kind<Promise<?>,? extends T> value, Function1<? super T,? extends Kind<Promise<?>,? extends R>> map)
default <A, B> PureIO<R,E,B>	PureIOMonad.flatMap(Kind<PureIO<R,E,?>,? extends A> value, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> map)
default <T, R> PureStream<F,R>	PureStreamMonad.flatMap(Kind<PureStream<F,?>,? extends T> value, Function1<? super T,? extends Kind<PureStream<F,?>,? extends R>> mapper)
default <T, V> Reader<R,V>	ReaderMonad.flatMap(Kind<Reader<R,?>,? extends T> value, Function1<? super T,? extends Kind<Reader<R,?>,? extends V>> map)
default <A, B> RIO<R,B>	RIOMonad.flatMap(Kind<RIO<R,?>,? extends A> value, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> map)
default <T, R> Kind<Sequence<?>,R>	SequenceMonad.flatMap(Kind<Sequence<?>,? extends T> value, Function1<? super T,? extends Kind<Sequence<?>,? extends R>> map)
default <T, R> State<S,R>	StateMonad.flatMap(Kind<State<S,?>,? extends T> value, Function1<? super T,? extends Kind<State<S,?>,? extends R>> map)
default <T, R> StateT<F,S,R>	StateTMonad.flatMap(Kind<StateT<F,S,?>,? extends T> value, Function1<? super T,? extends Kind<StateT<F,S,?>,? extends R>> map)
default <A, B> Task<B>	TaskMonad.flatMap(Kind<Task<?>,? extends A> value, Function1<? super A,? extends Kind<Task<?>,? extends B>> map)
default <T, R> Kind<Trampoline<?>,R>	TrampolineMonad.flatMap(Kind<Trampoline<?>,? extends T> value, Function1<? super T,? extends Kind<Trampoline<?>,? extends R>> map)
default <T, R> Kind<Try<?>,R>	TryMonad.flatMap(Kind<Try<?>,? extends T> value, Function1<? super T,? extends Kind<Try<?>,? extends R>> map)
default <A, B> UIO<B>	UIOMonad.flatMap(Kind<UIO<?>,? extends A> value, Function1<? super A,? extends Kind<UIO<?>,? extends B>> map)
default <A, B> URIO<R,B>	URIOMonad.flatMap(Kind<URIO<R,?>,? extends A> value, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> map)
default <T, R> Validation<E,R>	ValidationMonad.flatMap(Kind<Validation<E,?>,? extends T> value, Function1<? super T,? extends Kind<Validation<E,?>,? extends R>> map)
default <T, R> Writer<L,R>	WriterMonad.flatMap(Kind<Writer<L,?>,? extends T> value, Function1<? super T,? extends Kind<Writer<L,?>,? extends R>> map)
default <T, R> WriterT<F,L,R>	WriterTMonad.flatMap(Kind<WriterT<F,L,?>,? extends T> value, Function1<? super T,? extends Kind<WriterT<F,L,?>,? extends R>> map)
<A> MonadMTL.EffectE<F,E,A>	EffectEMonadError.handleErrorWith(Kind<MonadMTL.EffectE<F,E,?>,A> value, Function1<? super E,? extends Kind<MonadMTL.EffectE<F,E,?>,? extends A>> handler)
<A> MonadMTL.EffectR<F,R,E,A>	EffectRMonadError.handleErrorWith(Kind<MonadMTL.EffectR<F,R,E,?>,A> value, Function1<? super E,? extends Kind<MonadMTL.EffectR<F,R,E,?>,? extends A>> handler)
default <A> EIO<E,A>	EIOMonadError.handleErrorWith(Kind<EIO<E,?>,A> value, Function1<? super E,? extends Kind<EIO<E,?>,? extends A>> handler)
default <A> Either<L,A>	EitherMonadError.handleErrorWith(Kind<Either<L,?>,A> value, Function1<? super L,? extends Kind<Either<L,?>,? extends A>> handler)
default <A> EitherT<F,E,A>	EitherTMonadErrorFromMonad.handleErrorWith(Kind<EitherT<F,E,?>,A> value, Function1<? super E,? extends Kind<EitherT<F,E,?>,? extends A>> handler)
default <A> EitherT<F,E,A>	EitherTMonadErrorFromMonadError.handleErrorWith(Kind<EitherT<F,E,?>,A> value, Function1<? super E,? extends Kind<EitherT<F,E,?>,? extends A>> handler)
default <A> Kind<Eval<?>,A>	EvalMonadError.handleErrorWith(Kind<Eval<?>,A> value, Function1<? super Throwable,? extends Kind<Eval<?>,? extends A>> handler)
default <A> Kind<Future<?>,A>	FutureMonadThrow.handleErrorWith(Kind<Future<?>,A> value, Function1<? super Throwable,? extends Kind<Future<?>,? extends A>> handler)
default <A> IO<A>	IOMonadError.handleErrorWith(Kind<IO<?>,A> value, Function1<? super Throwable,? extends Kind<IO<?>,? extends A>> handler)
default <A> Kleisli<F,R,A>	KleisliMonadError.handleErrorWith(Kind<Kleisli<F,R,?>,A> value, Function1<? super E,? extends Kind<Kleisli<F,R,?>,? extends A>> handler)
<A> MonadMTL.EffectS<F,S,R,E,A>	MonadMTL.handleErrorWith(Kind<MonadMTL.EffectS<F,S,R,E,?>,A> value, Function1<? super E,? extends Kind<MonadMTL.EffectS<F,S,R,E,?>,? extends A>> handler)
default <A> Kind<Option<?>,A>	OptionMonadError.handleErrorWith(Kind<Option<?>,A> value, Function1<? super Unit,? extends Kind<Option<?>,? extends A>> handler)
default <A> OptionT<F,A>	OptionTMonadErrorFromMonad.handleErrorWith(Kind<OptionT<F,?>,A> value, Function1<? super Unit,? extends Kind<OptionT<F,?>,? extends A>> handler)
default <A> OptionT<F,A>	OptionTMonadErrorFromMonadError.handleErrorWith(Kind<OptionT<F,?>,A> value, Function1<? super E,? extends Kind<OptionT<F,?>,? extends A>> handler)
default <A> PureIO<R,E,A>	PureIOMonadError.handleErrorWith(Kind<PureIO<R,E,?>,A> value, Function1<? super E,? extends Kind<PureIO<R,E,?>,? extends A>> handler)
default <A> RIO<R,A>	RIOMonadError.handleErrorWith(Kind<RIO<R,?>,A> value, Function1<? super Throwable,? extends Kind<RIO<R,?>,? extends A>> handler)
default <A> StateT<F,S,A>	StateTMonadError.handleErrorWith(Kind<StateT<F,S,?>,A> value, Function1<? super E,? extends Kind<StateT<F,S,?>,? extends A>> handler)
default <A> Task<A>	TaskMonadError.handleErrorWith(Kind<Task<?>,A> value, Function1<? super Throwable,? extends Kind<Task<?>,? extends A>> handler)
default <A> Kind<Try<?>,A>	TryMonadError.handleErrorWith(Kind<Try<?>,A> value, Function1<? super Throwable,? extends Kind<Try<?>,? extends A>> handler)
default <A> UIO<A>	UIOMonadError.handleErrorWith(Kind<UIO<?>,A> value, Function1<? super Throwable,? extends Kind<UIO<?>,? extends A>> handler)
default <A> URIO<R,A>	URIOMonadError.handleErrorWith(Kind<URIO<R,?>,A> value, Function1<? super Throwable,? extends Kind<URIO<R,?>,? extends A>> handler)
default <A> Validation<E,A>	ValidationMonadError.handleErrorWith(Kind<Validation<E,?>,A> value, Function1<? super E,? extends Kind<Validation<E,?>,? extends A>> handler)
default <A> WriterT<F,L,A>	WriterTMonadError.handleErrorWith(Kind<WriterT<F,L,?>,A> value, Function1<? super E,? extends Kind<WriterT<F,L,?>,? extends A>> handler)
private <T, R> Trampoline<Kind<Either<L,?>,R>>	EitherMonad.loop(T value, Function1<T,? extends Kind<Either<L,?>,Either<T,R>>> map)
private <T, R> Trampoline<Kind<Option<?>,R>>	OptionMonad.loop(T value, Function1<T,? extends Kind<Option<?>,Either<T,R>>> map)
private <T, R> Trampoline<Kind<Try<?>,R>>	TryMonad.loop(T value, Function1<T,? extends Kind<Try<?>,Either<T,R>>> map)
private <T, R> Trampoline<Kind<Validation<E,?>,R>>	ValidationMonad.loop(T value, Function1<T,? extends Kind<Validation<E,?>,Either<T,R>>> map)
default <T> Future<Sequence<T>>	EIORuntime.parRun(Sequence<Kind<EIO<E,?>,T>> values, Executor executor)
default <T> Future<Sequence<T>>	IORuntime.parRun(Sequence<Kind<IO<?>,T>> values, Executor executor)
default <T> Future<Sequence<T>>	PureIORuntime.parRun(Sequence<Kind<PureIO<R,E,?>,T>> values, Executor executor)
default <T> Future<Sequence<T>>	RIORuntime.parRun(Sequence<Kind<RIO<R,?>,T>> values, Executor executor)
default <T> Future<Sequence<T>>	TaskRuntime.parRun(Sequence<Kind<Task<?>,T>> values, Executor executor)
default <T> Future<Sequence<T>>	UIORuntime.parRun(Sequence<Kind<UIO<?>,T>> values, Executor executor)
default <T> Future<Sequence<T>>	URIORuntime.parRun(Sequence<Kind<URIO<R,?>,T>> values, Executor executor)
default <T> Sequence<T>	EIORuntime.run(Sequence<Kind<EIO<E,?>,T>> values)
default <T> Sequence<T>	IORuntime.run(Sequence<Kind<IO<?>,T>> values)
<R extends Kind<F, Either<E, A>>> R	MonadMTL.EffectE.run(Function<Kind<F,? extends Either<E,A>>,R> fixer)
default <T> Sequence<T>	PureIORuntime.run(Sequence<Kind<PureIO<R,E,?>,T>> values)
default <T> Sequence<T>	RIORuntime.run(Sequence<Kind<RIO<R,?>,T>> values)
default <T> Sequence<T>	TaskRuntime.run(Sequence<Kind<Task<?>,T>> values)
default <T> Sequence<T>	UIORuntime.run(Sequence<Kind<UIO<?>,T>> values)
default <T> Sequence<T>	URIORuntime.run(Sequence<Kind<URIO<R,?>,T>> values)
default <T, R> Kind<Either<L,?>,R>	EitherMonad.tailRecM(T value, Function1<T,? extends Kind<Either<L,?>,Either<T,R>>> map)
default <T, R> Kind<Option<?>,R>	OptionMonad.tailRecM(T value, Function1<T,? extends Kind<Option<?>,Either<T,R>>> map)
default <T, R> Kind<Try<?>,R>	TryMonad.tailRecM(T value, Function1<T,? extends Kind<Try<?>,Either<T,R>>> map)
default <T, R> Kind<Validation<E,?>,R>	ValidationMonad.tailRecM(T value, Function1<T,? extends Kind<Validation<E,?>,Either<T,R>>> map)
default <G extends Kind<G, ?>, A, B> Kind<G,Kind<Const<T,?>,B>>	ConstTraverse.traverse(Applicative<G> applicative, Kind<Const<T,?>,A> value, Function1<? super A,? extends Kind<G,? extends B>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Either<L,?>,R>>	EitherTraverse.traverse(Applicative<G> applicative, Kind<Either<L,?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Id<?>,R>>	IdTraverse.traverse(Applicative<G> applicative, Kind<Id<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Option<?>,R>>	OptionTraverse.traverse(Applicative<G> applicative, Kind<Option<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Sequence<?>,R>>	SequenceTraverse.traverse(Applicative<G> applicative, Kind<Sequence<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Try<?>,R>>	TryTraverse.traverse(Applicative<G> applicative, Kind<Try<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)

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

Modifier	Constructor	Description
	EffectE(Kind<EitherT<F,E,?>,A> value)
	EffectR(Kind<Kleisli<MonadMTL.EffectE<F,E,?>,R,?>,A> value)
	EffectS(Kind<StateT<MonadMTL.EffectR<F,R,E,?>,S,?>,A> value)

Uses of Kind in com.github.tonivade.purefun.monad

Subinterfaces of Kind in com.github.tonivade.purefun.monad

Modifier and Type	Interface	Description
interface	IO<T>
interface	IOOf<T>
interface	Reader<R,A>
interface	ReaderOf<R,A>
interface	State<S,A>
interface	StateOf<S,A>
interface	Writer<L,A>
interface	WriterOf<L,A>

Classes in com.github.tonivade.purefun.monad that implement Kind

Modifier and Type	Class	Description
static final class	IO.Async<T>
static final class	IO.Delay<T>
static final class	IO.Failure<T>
static final class	IO.FlatMapped<T,R>
static final class	IO.Pure<T>
static final class	IO.Recover<T>
static final class	IO.Suspend<T>

Fields in com.github.tonivade.purefun.monad declared as Kind

Modifier and Type	Field	Description
private Kind<IO<?>,Unit>	IOConnection.Cancellable.cancelToken
private final Kind<IO<?>,? extends T>	IO.FlatMapped.current
private final Kind<IO<?>,T>	IO.Recover.current

Fields in com.github.tonivade.purefun.monad with type parameters of type Kind

Modifier and Type	Field	Description
private final Function1<Consumer1<? super Try<? extends T>>,Kind<IO<?>,Unit>>	IO.Async.callback
private final Producer<? extends Kind<IO<?>,? extends T>>	IO.Suspend.lazy
private final PartialFunction1<? super Throwable,? extends Kind<IO<?>,? extends T>>	IO.Recover.mapper
private final Function1<? super T,? extends Kind<IO<?>,? extends R>>	IO.FlatMapped.next
private final Deque<PartialFunction1<? super Throwable,? extends Kind<IO<?>,? extends T>>>	StackItem.recover

Methods in com.github.tonivade.purefun.monad that return Kind

Modifier and Type	Method	Description
private static <T, U> Kind<IO<?>,T>	IO.unwrap(Kind<IO<?>,T> current, CallStack<U> stack, Function1<Kind<IO<?>,? extends T>,Kind<IO<?>,? extends U>> next)

Methods in com.github.tonivade.purefun.monad with parameters of type Kind

Modifier and Type	Method	Description
default <R> IO<R>	IO.andThen(Kind<IO<?>,? extends R> after)
default <R> State<S,R>	State.andThen(Kind<State<S,?>,? extends R> next)
default <R> Writer<L,R>	Writer.andThen(Kind<Writer<L,?>,? extends R> next)
default <R> IO<R>	IO.ap(Kind<IO<?>,? extends Function1<? super T,? extends R>> apply)
static <T extends AutoCloseable, R> IO<R>	IO.bracket(Kind<IO<?>,? extends T> acquire, Function1<? super T,? extends Kind<IO<?>,? extends R>> use)
static <T, R> IO<R>	IO.bracket(Kind<IO<?>,? extends T> acquire, Function1<? super T,? extends Kind<IO<?>,? extends R>> use, Consumer1<? super T> release)
static <T, R> IO<R>	IO.bracket(Kind<IO<?>,? extends T> acquire, Function1<? super T,? extends Kind<IO<?>,? extends R>> use, Function1<? super T,? extends Kind<IO<?>,Unit>> release)
static <A, B, C> IO<C>	IO.parMap2(Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb, Function2<? super A,? super B,? extends C> mapper)
static <A, B, C> IO<C>	IO.parMap2(Executor executor, Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb, Function2<? super A,? super B,? extends C> mapper)
static <A, B> IO<Either<A,B>>	IO.race(Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
static <A, B> IO<Either<A,B>>	IO.race(Executor executor, Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
static <A, B> IO<Either<Tuple2<A,Fiber<IO<?>,B>>,Tuple2<Fiber<IO<?>,A>,B>>>	IO.racePair(Executor executor, Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
private static <T> Promise<T>	IO.runAsync(Kind<IO<?>,T> current, IOConnection connection)
private static <T, U, V> Promise<T>	IO.runAsync(Kind<IO<?>,T> current, IOConnection connection, CallStack<T> stack, Promise<T> promise)
void	IOConnection.Cancellable.setCancelToken(Kind<IO<?>,Unit> cancel)
void	IOConnection.setCancelToken(Kind<IO<?>,Unit> cancel)
void	IOConnection.Uncancellable.setCancelToken(Kind<IO<?>,Unit> cancel)
static <T> IO<T>	IOOf.toIO(Kind<IO<?>,? extends T> value)
static <R, A> Reader<R,A>	ReaderOf.toReader(Kind<Reader<R,?>,? extends A> value)
static <S, A> State<S,A>	StateOf.toState(Kind<State<S,?>,? extends A> value)
static <L, A> Writer<L,A>	WriterOf.toWriter(Kind<Writer<L,?>,? extends A> value)
static <A, B> IO<Tuple2<A,B>>	IO.tuple(Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
static <A, B> IO<Tuple2<A,B>>	IO.tuple(Executor executor, Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
private static <T, U> Kind<IO<?>,T>	IO.unwrap(Kind<IO<?>,T> current, CallStack<U> stack, Function1<Kind<IO<?>,? extends T>,Kind<IO<?>,? extends U>> next)

Method parameters in com.github.tonivade.purefun.monad with type arguments of type Kind

Modifier and Type	Method	Description
void	CallStack.add(PartialFunction1<? super Throwable,? extends Kind<IO<?>,? extends T>> mapError)
void	StackItem.add(PartialFunction1<? super Throwable,? extends Kind<IO<?>,? extends T>> mapError)
static <T extends AutoCloseable, R> IO<R>	IO.bracket(Kind<IO<?>,? extends T> acquire, Function1<? super T,? extends Kind<IO<?>,? extends R>> use)
static <T, R> IO<R>	IO.bracket(Kind<IO<?>,? extends T> acquire, Function1<? super T,? extends Kind<IO<?>,? extends R>> use, Consumer1<? super T> release)
static <T, R> IO<R>	IO.bracket(Kind<IO<?>,? extends T> acquire, Function1<? super T,? extends Kind<IO<?>,? extends R>> use, Function1<? super T,? extends Kind<IO<?>,Unit>> release)
static <T> IO<T>	IO.cancellable(Function1<Consumer1<? super Try<? extends T>>,Kind<IO<?>,Unit>> callback)
default <R> IO<R>	IO.flatMap(Function1<? super T,? extends Kind<IO<?>,? extends R>> map)
default <B> Reader<R,B>	Reader.flatMap(Function1<? super A,? extends Kind<Reader<R,?>,? extends B>> mapper)
default <R> State<S,R>	State.flatMap(Function1<? super A,? extends Kind<State<S,?>,? extends R>> mapper)
default <B> Writer<L,B>	Writer.flatMap(Function1<? super A,? extends Kind<Writer<L,?>,? extends B>> mapper)
default IO<T>	IO.recoverWith(PartialFunction1<? super Throwable,? extends Kind<IO<?>,? extends T>> mapper)
default <R> IO<R>	IO.redeemWith(Function1<? super Throwable,? extends Kind<IO<?>,? extends R>> mapError, Function1<? super T,? extends Kind<IO<?>,? extends R>> mapper)
static IO<Unit>	IO.sequence(Sequence<? extends Kind<IO<?>,?>> sequence)
static <T> IO<T>	IO.suspend(Producer<? extends Kind<IO<?>,? extends T>> lazy)
static <A> IO<Sequence<A>>	IO.traverse(Sequence<? extends Kind<IO<?>,A>> sequence)
static <A> IO<Sequence<A>>	IO.traverse(Executor executor, Sequence<? extends Kind<IO<?>,A>> sequence)
private static <T, U> Kind<IO<?>,T>	IO.unwrap(Kind<IO<?>,T> current, CallStack<U> stack, Function1<Kind<IO<?>,? extends T>,Kind<IO<?>,? extends U>> next)
private static <T, U> Kind<IO<?>,T>	IO.unwrap(Kind<IO<?>,T> current, CallStack<U> stack, Function1<Kind<IO<?>,? extends T>,Kind<IO<?>,? extends U>> next)

Constructor parameters in com.github.tonivade.purefun.monad with type arguments of type Kind

Modifier	Constructor	Description
private	Async(Function1<Consumer1<? super Try<? extends T>>,Kind<IO<?>,Unit>> callback)
private	FlatMapped(IO<? extends T> current, Function1<? super T,? extends Kind<IO<?>,? extends R>> next)
private	Recover(IO<T> current, PartialFunction1<? super Throwable,? extends Kind<IO<?>,? extends T>> mapper)
private	Suspend(Producer<? extends Kind<IO<?>,? extends T>> lazy)

Uses of Kind in com.github.tonivade.purefun.stream

Classes in com.github.tonivade.purefun.stream with type parameters of type Kind

Modifier and Type	Class	Description
final class	Cons<F extends Kind<F,?>,T>
final class	Nil<F extends Kind<F,?>,T>
interface	PureStream<F extends Kind<F,?>,T>
static interface	PureStream.Of<F extends Kind<F,?>>
interface	PureStreamOf<F extends Kind<F,?>,T>
final class	Suspend<F extends Kind<F,?>,T>

Subinterfaces of Kind in com.github.tonivade.purefun.stream

Modifier and Type	Interface	Description
interface	PureStream<F extends Kind<F,?>,T>
interface	PureStreamOf<F extends Kind<F,?>,T>

Classes in com.github.tonivade.purefun.stream that implement Kind

Modifier and Type	Class	Description
final class	Cons<F extends Kind<F,?>,T>
final class	Nil<F extends Kind<F,?>,T>
final class	Suspend<F extends Kind<F,?>,T>

Fields in com.github.tonivade.purefun.stream declared as Kind

Modifier and Type	Field	Description
private final Kind<F,PureStream<F,T>>	Suspend.evalStream
private final Kind<F,T>	Cons.head

Methods in com.github.tonivade.purefun.stream with type parameters of type Kind

Modifier and Type	Method	Description
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.cons(T head, PureStream<F,? extends T> tail, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.empty(F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.eval(Kind<F,? extends T> value, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.from(Sequence<? extends T> sequence, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.from(Iterable<? extends T> iterable, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.from(Stream<? extends T> stream, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.iterate(Producer<? extends T> generator, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.iterate(T seed, Operator1<T> generator, F... reified)
static <F extends Kind<F, ?>, A> PureStream<F,A>	PureStream.merge(PureStream<F,A> s1, PureStream<F,A> s2, F... reified)
static <F extends Kind<F, ?>> PureStream.Of<F>	PureStream.of(MonadDefer<F> monad)
static <F extends Kind<F, ?>> PureStream.Of<F>	PureStream.of(F... reified)
static <F extends Kind<F, ?>> PureStream.Of<F>	PureStream.of(Class<F> type)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.pure(T value, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.suspend(Producer<? extends PureStream<F,? extends T>> lazy, F... reified)
default <G extends Kind<G, ?>, R> PureStream<G,R>	PureStream.through(Function1<PureStream<F,T>,PureStream<G,R>> function)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStreamOf.toPureStream(Kind<PureStream<F,?>,? extends T> value)
static <F extends Kind<F, ?>, T, S> PureStream<F,T>	PureStream.unfold(S seed, Function1<? super S,Option<Tuple2<? extends T,? extends S>>> function, F... reified)
static <F extends Kind<F, ?>, A, B> PureStream<F,Tuple2<A,B>>	PureStream.zip(PureStream<F,? extends A> s1, PureStream<F,? extends B> s2, F... reified)
static <F extends Kind<F, ?>, A, B, R> PureStream<F,R>	PureStream.zipWith(PureStream<F,? extends A> s1, PureStream<F,? extends B> s2, Function2<? super A,? super B,? extends R> combinator, F... reified)
static <F extends Kind<F, ?>, A> PureStream<F,Tuple2<A,Integer>>	PureStream.zipWithIndex(PureStream<F,? extends A> stream, F... reified)

Methods in com.github.tonivade.purefun.stream that return Kind

Modifier and Type	Method	Description
default Kind<F,Sequence<T>>	PureStream.asSequence()
default Kind<F,String>	PureStream.asString()
default Kind<F,Unit>	PureStream.drain()
Kind<F,Boolean>	Cons.exists(Matcher1<? super T> matcher)
Kind<F,Boolean>	Nil.exists(Matcher1<? super T> matcher)
Kind<F,Boolean>	PureStream.exists(Matcher1<? super T> matcher)
Kind<F,Boolean>	Suspend.exists(Matcher1<? super T> matcher)
<R> Kind<F,R>	Cons.foldLeft(R begin, Function2<? super R,? super T,? extends R> combinator)
<R> Kind<F,R>	Nil.foldLeft(R begin, Function2<? super R,? super T,? extends R> combinator)
<R> Kind<F,R>	PureStream.foldLeft(R begin, Function2<? super R,? super T,? extends R> combinator)
<R> Kind<F,R>	Suspend.foldLeft(R begin, Function2<? super R,? super T,? extends R> combinator)
<R> Kind<F,R>	Cons.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> Kind<F,R>	Nil.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> Kind<F,R>	PureStream.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> Kind<F,R>	Suspend.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
Kind<F,Boolean>	Cons.forall(Matcher1<? super T> matcher)
Kind<F,Boolean>	Nil.forall(Matcher1<? super T> matcher)
Kind<F,Boolean>	PureStream.forall(Matcher1<? super T> matcher)
Kind<F,Boolean>	Suspend.forall(Matcher1<? super T> matcher)
Kind<F,Option<T>>	Cons.headOption()
Kind<F,Option<T>>	Nil.headOption()
Kind<F,Option<T>>	PureStream.headOption()
Kind<F,Option<T>>	Suspend.headOption()
Kind<F,Option<Tuple2<Kind<F,T>,PureStream<F,T>>>>	Cons.split()
Kind<F,Option<Tuple2<Kind<F,T>,PureStream<F,T>>>>	Nil.split()
Kind<F,Option<Tuple2<Kind<F,T>,PureStream<F,T>>>>	PureStream.split()
Kind<F,Option<Tuple2<Kind<F,T>,PureStream<F,T>>>>	Suspend.split()

Methods in com.github.tonivade.purefun.stream that return types with arguments of type Kind

Modifier and Type	Method	Description
Kind<F,Option<Tuple2<Kind<F,T>,PureStream<F,T>>>>	Cons.split()
Kind<F,Option<Tuple2<Kind<F,T>,PureStream<F,T>>>>	Nil.split()
Kind<F,Option<Tuple2<Kind<F,T>,PureStream<F,T>>>>	PureStream.split()
Kind<F,Option<Tuple2<Kind<F,T>,PureStream<F,T>>>>	Suspend.split()

Methods in com.github.tonivade.purefun.stream with parameters of type Kind

Modifier and Type	Method	Description
default <R> PureStream<F,R>	PureStream.andThen(Kind<PureStream<F,?>,? extends R> next)
PureStream<F,T>	Cons.append(Kind<F,? extends T> other)
PureStream<F,T>	Nil.append(Kind<F,? extends T> other)
PureStream<F,T>	PureStream.append(Kind<F,? extends T> other)
PureStream<F,T>	Suspend.append(Kind<F,? extends T> other)
private <R> PureStream<F,R>	Cons.cons(Kind<F,R> h, PureStream<F,R> t)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.cons(T head, PureStream<F,? extends T> tail, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.empty(F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.eval(Kind<F,? extends T> value, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.eval(Kind<F,? extends T> value, F... reified)
default <T> PureStream<F,T>	PureStream.Of.eval(Kind<F,? extends T> value)
<R> Kind<F,R>	Cons.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> Kind<F,R>	Nil.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> Kind<F,R>	PureStream.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> Kind<F,R>	Suspend.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.from(Sequence<? extends T> sequence, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.from(Iterable<? extends T> iterable, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.from(Stream<? extends T> stream, F... reified)
PureStream<F,T>	Cons.intersperse(Kind<F,? extends T> value)
PureStream<F,T>	Nil.intersperse(Kind<F,? extends T> value)
PureStream<F,T>	PureStream.intersperse(Kind<F,? extends T> value)
PureStream<F,T>	Suspend.intersperse(Kind<F,? extends T> value)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.iterate(Producer<? extends T> generator, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.iterate(T seed, Operator1<T> generator, F... reified)
default <R> PureStream<F,R>	PureStream.mapReplace(Kind<F,? extends R> next)
static <F extends Kind<F, ?>, A> PureStream<F,A>	PureStream.merge(PureStream<F,A> s1, PureStream<F,A> s2, F... reified)
static <F extends Kind<F, ?>> PureStream.Of<F>	PureStream.of(F... reified)
PureStream<F,T>	Cons.prepend(Kind<F,? extends T> other)
PureStream<F,T>	Nil.prepend(Kind<F,? extends T> other)
PureStream<F,T>	PureStream.prepend(Kind<F,? extends T> other)
PureStream<F,T>	Suspend.prepend(Kind<F,? extends T> other)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.pure(T value, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStream.suspend(Producer<? extends PureStream<F,? extends T>> lazy, F... reified)
static <F extends Kind<F, ?>, T> PureStream<F,T>	PureStreamOf.toPureStream(Kind<PureStream<F,?>,? extends T> value)
static <F extends Kind<F, ?>, T, S> PureStream<F,T>	PureStream.unfold(S seed, Function1<? super S,Option<Tuple2<? extends T,? extends S>>> function, F... reified)
static <F extends Kind<F, ?>, A, B> PureStream<F,Tuple2<A,B>>	PureStream.zip(PureStream<F,? extends A> s1, PureStream<F,? extends B> s2, F... reified)
static <F extends Kind<F, ?>, A, B, R> PureStream<F,R>	PureStream.zipWith(PureStream<F,? extends A> s1, PureStream<F,? extends B> s2, Function2<? super A,? super B,? extends R> combinator, F... reified)
static <F extends Kind<F, ?>, A> PureStream<F,Tuple2<A,Integer>>	PureStream.zipWithIndex(PureStream<F,? extends A> stream, F... reified)

Method parameters in com.github.tonivade.purefun.stream with type arguments of type Kind

Modifier and Type	Method	Description
<R> PureStream<F,R>	Cons.flatMap(Function1<? super T,? extends Kind<PureStream<F,?>,? extends R>> map)
<R> PureStream<F,R>	Nil.flatMap(Function1<? super T,? extends Kind<PureStream<F,?>,? extends R>> map)
<R> PureStream<F,R>	PureStream.flatMap(Function1<? super T,? extends Kind<PureStream<F,?>,? extends R>> map)
<R> PureStream<F,R>	Suspend.flatMap(Function1<? super T,? extends Kind<PureStream<F,?>,? extends R>> map)
<R> Kind<F,R>	Cons.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> Kind<F,R>	Cons.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> Kind<F,R>	Nil.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> Kind<F,R>	Nil.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> Kind<F,R>	PureStream.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> Kind<F,R>	PureStream.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> Kind<F,R>	Suspend.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> Kind<F,R>	Suspend.foldRight(Kind<F,? extends R> begin, Function2<? super T,? super Kind<F,? extends R>,? extends Kind<F,? extends R>> combinator)
<R> PureStream<F,R>	Cons.mapEval(Function1<? super T,? extends Kind<F,? extends R>> mapper)
<R> PureStream<F,R>	Nil.mapEval(Function1<? super T,? extends Kind<F,? extends R>> mapper)
<R> PureStream<F,R>	PureStream.mapEval(Function1<? super T,? extends Kind<F,? extends R>> mapper)
<R> PureStream<F,R>	Suspend.mapEval(Function1<? super T,? extends Kind<F,? extends R>> mapper)
private <R> PureStream<F,R>	Suspend.suspend(Producer<Kind<F,PureStream<F,R>>> stream)
private <R> PureStream<F,R>	Cons.suspendF(Producer<Kind<F,PureStream<F,R>>> stream)

Constructors in com.github.tonivade.purefun.stream with parameters of type Kind

Modifier	Constructor	Description
(package private)	Cons(MonadDefer<F> monad, Kind<F,T> head, PureStream<F,T> tail)
(package private)	Suspend(MonadDefer<F> monad, Kind<F,PureStream<F,T>> stream)

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

Classes in com.github.tonivade.purefun.transformer with type parameters of type Kind

Modifier and Type	Interface	Description
interface	EitherT<F extends Kind<F,?>,L,R>
interface	EitherTOf<F extends Kind<F,?>,L,R>
interface	Kleisli<F extends Kind<F,?>,Z,A>
interface	KleisliOf<F extends Kind<F,?>,Z,A>
interface	OptionT<F extends Kind<F,?>,T>
interface	OptionTOf<F extends Kind<F,?>,T>
interface	StateT<F extends Kind<F,?>,S,A>
interface	StateTOf<F extends Kind<F,?>,S,A>
interface	WriterT<F extends Kind<F,?>,L,A>
interface	WriterTOf<F extends Kind<F,?>,L,A>

Subinterfaces of Kind in com.github.tonivade.purefun.transformer

Modifier and Type	Interface	Description
interface	EitherT<F extends Kind<F,?>,L,R>
interface	EitherTOf<F extends Kind<F,?>,L,R>
interface	Kleisli<F extends Kind<F,?>,Z,A>
interface	KleisliOf<F extends Kind<F,?>,Z,A>
interface	OptionT<F extends Kind<F,?>,T>
interface	OptionTOf<F extends Kind<F,?>,T>
interface	StateT<F extends Kind<F,?>,S,A>
interface	StateTOf<F extends Kind<F,?>,S,A>
interface	WriterT<F extends Kind<F,?>,L,A>
interface	WriterTOf<F extends Kind<F,?>,L,A>

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

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)
static <F extends Kind<F, ?>, S, A, B, C> StateT<F,S,C>	StateT.map2(StateT<F,S,? extends A> sa, StateT<F,S,? extends B> sb, Function2<? super A,? super B,? extends C> mapper)
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, ?>, L, R> EitherT<F,L,R>	EitherTOf.toEitherT(Kind<EitherT<F,L,?>,? extends R> value)
static <F extends Kind<F, ?>, Z, A> Kleisli<F,Z,A>	KleisliOf.toKleisli(Kind<Kleisli<F,Z,?>,? extends A> value)
static <F extends Kind<F, ?>, T> OptionT<F,T>	OptionTOf.toOptionT(Kind<OptionT<F,?>,? extends T> value)
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateTOf.toStateT(Kind<StateT<F,S,?>,? extends A> value)
static <F extends Kind<F, ?>, L, A> WriterT<F,L,A>	WriterTOf.toWriterT(Kind<WriterT<F,L,?>,? extends A> value)
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)

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

Modifier and Type	Method	Description
default Kind<F,A>	StateT.eval(S state)
default <V> Kind<F,Either<L,V>>	EitherT.flatMapF(Function1<? super R,? extends Kind<F,? extends Either<L,V>>> map)
default <R> Kind<F,Option<R>>	OptionT.flatMapF(Function1<? super T,? extends Kind<F,? extends Option<R>>> map)
default <V> Kind<F,V>	EitherT.fold(Function1<? super L,? extends V> leftMapper, Function1<? super R,? extends V> rightMapper)
default <R> Kind<F,R>	OptionT.fold(Producer<? extends R> orElse, Function1<? super T,? extends R> map)
default Kind<F,R>	EitherT.get()
default Kind<F,L>	EitherT.getLeft()
default Kind<F,L>	WriterT.getLog()
default Kind<F,R>	EitherT.getOrElse(Producer<? extends R> orElse)
default Kind<F,R>	EitherT.getOrElse(R orElse)
default Kind<F,T>	OptionT.getOrElse(Producer<? extends T> orElse)
default Kind<F,T>	OptionT.getOrElse(T orElse)
default Kind<F,T>	OptionT.getOrElseThrow()
default Kind<F,R>	EitherT.getRight()
default Kind<F,A>	WriterT.getValue()
default Kind<F,Boolean>	OptionT.isEmpty()
default Kind<F,Boolean>	EitherT.isLeft()
default Kind<F,Boolean>	EitherT.isRight()
Kind<F,A>	Kleisli.run(Z value)
Kind<F,Tuple2<S,A>>	StateT.run(S state)
Kind<F,Either<L,R>>	EitherT.value()
Kind<F,Option<T>>	OptionT.value()
Kind<F,Tuple2<L,A>>	WriterT.value()

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

Modifier and Type	Method	Description
default <V> EitherT<F,L,V>	EitherT.andThen(Kind<EitherT<F,L,?>,? extends V> next)
default <R> Kleisli<F,Z,R>	Kleisli.andThen(Kind<Kleisli<F,Z,?>,? extends R> next)
default <R> OptionT<F,R>	OptionT.andThen(Kind<OptionT<F,?>,? extends R> next)
default <R> StateT<F,S,R>	StateT.andThen(Kind<StateT<F,S,?>,? extends R> next)
default <R> WriterT<F,L,R>	WriterT.andThen(Kind<WriterT<F,L,?>,? extends R> next)
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, R> EitherT<F,L,R>	EitherT.of(Monad<F> monad, Kind<F,Either<L,R>> value)
static <F extends Kind<F, ?>, T> OptionT<F,T>	OptionT.of(Monad<F> monad, Kind<F,Option<T>> value)
static <F extends Kind<F, ?>, L, R> EitherT<F,L,R>	EitherTOf.toEitherT(Kind<EitherT<F,L,?>,? extends R> value)
static <F extends Kind<F, ?>, Z, A> Kleisli<F,Z,A>	KleisliOf.toKleisli(Kind<Kleisli<F,Z,?>,? extends A> value)
static <F extends Kind<F, ?>, T> OptionT<F,T>	OptionTOf.toOptionT(Kind<OptionT<F,?>,? extends T> value)
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateTOf.toStateT(Kind<StateT<F,S,?>,? extends A> value)
static <F extends Kind<F, ?>, L, A> WriterT<F,L,A>	WriterTOf.toWriterT(Kind<WriterT<F,L,?>,? extends A> value)
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)

Method parameters in com.github.tonivade.purefun.transformer with type arguments of type Kind

Modifier and Type	Method	Description
default <V> EitherT<F,L,V>	EitherT.flatMap(Function1<? super R,? extends Kind<EitherT<F,L,?>,? extends V>> map)
default <R> Kleisli<F,Z,R>	Kleisli.flatMap(Function1<? super A,? extends Kind<Kleisli<F,Z,?>,? extends R>> map)
default <R> OptionT<F,R>	OptionT.flatMap(Function1<? super T,? extends Kind<OptionT<F,?>,? extends R>> map)
default <R> StateT<F,S,R>	StateT.flatMap(Function1<? super A,? extends Kind<StateT<F,S,?>,? extends R>> map)
default <R> WriterT<F,L,R>	WriterT.flatMap(Function1<? super A,? extends Kind<WriterT<F,L,?>,? extends R>> mapper)
default <V> Kind<F,Either<L,V>>	EitherT.flatMapF(Function1<? super R,? extends Kind<F,? extends Either<L,V>>> map)
default <R> Kind<F,Option<R>>	OptionT.flatMapF(Function1<? super T,? extends Kind<F,? extends Option<R>>> map)
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, ?>, S, A> StateT<F,S,A>	StateT.of(Monad<F> monad, Function1<S,Kind<F,Tuple2<S,A>>> run)
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateT.state(Monad<F> monad, Function1<S,Kind<F,Tuple2<S,A>>> run)

Uses of Kind in com.github.tonivade.purefun.type

Subinterfaces of Kind in com.github.tonivade.purefun.type

Modifier and Type	Interface	Description
interface	ConstOf<T,A>
interface	Either<L,R>	This type represents two possible values, called left or right.
interface	EitherOf<L,R>
interface	Eval<A>	This is a monad that allows to control the evaluation of a computation or a value.
interface	EvalOf<A>
interface	IdOf<T>
interface	Option<T>	This type represents the presence or absence of a value, similar to Optional
interface	OptionOf<T>
interface	Try<T>	This type represents the success or failure of a computation.
interface	TryOf<T>
interface	Validation<E,T>	This type represents the validity or not of a value.
interface	ValidationOf<E,T>

Classes in com.github.tonivade.purefun.type that implement Kind

Modifier and Type	Class	Description
final record	Const<T,A>
static final record	Either.Left<L,R>
static final record	Either.Right<L,R>
static final class	Eval.Defer<A>
static final class	Eval.Done<A>
static final class	Eval.FlatMapped<A,B>
final record	Id<T>	This is the identity monad.
static final class	Option.None<T>
static final record	Option.Some<T>
static final record	Try.Failure<T>
static final record	Try.Success<T>
static final record	Validation.Invalid<E,T>
static final record	Validation.Valid<E,T>

Fields in com.github.tonivade.purefun.type with type parameters of type Kind

Modifier and Type	Field	Description
private final Producer<? extends Kind<Eval<?>,? extends A>>	Eval.Defer.deferred
private final Function1<? super A,? extends Kind<Eval<?>,? extends B>>	Eval.FlatMapped.run
private final Producer<? extends Kind<Eval<?>,? extends A>>	Eval.FlatMapped.start

Methods in com.github.tonivade.purefun.type with parameters of type Kind

Modifier and Type	Method	Description
default <T> Either<L,T>	Either.ap(Kind<Either<L,?>,? extends Function1<? super R,? extends T>> apply)
<R> Id<R>	Id.ap(Kind<Id<?>,? extends Function1<? super T,? extends R>> apply)
default <R> Option<R>	Option.ap(Kind<Option<?>,? extends Function1<? super T,? extends R>> apply)
default <R> Try<R>	Try.ap(Kind<Try<?>,? extends Function1<? super T,? extends R>> apply)
default Either<L,R>	Either.orElse(Kind<Either<L,?>,R> orElse)
default Option<T>	Option.orElse(Kind<Option<?>,T> orElse)
default Try<T>	Try.orElse(Kind<Try<?>,T> orElse)
default Validation<E,T>	Validation.orElse(Kind<Validation<E,?>,T> orElse)
static <T, A> Const<T,A>	ConstOf.toConst(Kind<Const<T,?>,? extends A> value)
static <L, R> Either<L,R>	EitherOf.toEither(Kind<Either<L,?>,? extends R> value)
static <A> Eval<A>	EvalOf.toEval(Kind<Eval<?>,? extends A> value)
static <T> Id<T>	IdOf.toId(Kind<Id<?>,? extends T> value)
static <T> Option<T>	OptionOf.toOption(Kind<Option<?>,? extends T> value)
static <T> Try<T>	TryOf.toTry(Kind<Try<?>,? extends T> value)
static <E, T> Validation<E,T>	ValidationOf.toValidation(Kind<Validation<E,?>,? extends T> value)

Method parameters in com.github.tonivade.purefun.type with type arguments of type Kind

Modifier and Type	Method	Description
static <T> Eval<T>	Eval.defer(Producer<? extends Kind<Eval<?>,? extends T>> eval)
default Either<L,R>	Either.filterOrElse(Matcher1<? super R> matcher, Producer<? extends Kind<Either<L,?>,R>> orElse)
default Try<T>	Try.filterOrElse(Matcher1<? super T> matcher, Producer<? extends Kind<Try<?>,? extends T>> producer)
default Validation<E,T>	Validation.filterOrElse(Matcher1<? super T> matcher, Producer<? extends Kind<Validation<E,?>,T>> orElse)
default <T> Either<L,T>	Either.flatMap(Function1<? super R,? extends Kind<Either<L,?>,? extends T>> map)
<R> Eval<R>	Eval.Defer.flatMap(Function1<? super A,? extends Kind<Eval<?>,? extends R>> map)
<R> Eval<R>	Eval.Done.flatMap(Function1<? super A,? extends Kind<Eval<?>,? extends R>> map)
<R> Eval<R>	Eval.flatMap(Function1<? super A,? extends Kind<Eval<?>,? extends R>> map)
<R> Eval<R>	Eval.FlatMapped.flatMap(Function1<? super B,? extends Kind<Eval<?>,? extends R>> map)
<R> Id<R>	Id.flatMap(Function1<? super T,? extends Kind<Id<?>,? extends R>> map)
default <R> Option<R>	Option.flatMap(Function1<? super T,? extends Kind<Option<?>,? extends R>> map)
default <R> Try<R>	Try.flatMap(Function1<? super T,? extends Kind<Try<?>,? extends R>> mapper)
default <R> Validation<E,R>	Validation.flatMap(Function1<? super T,? extends Kind<Validation<E,?>,? extends R>> mapper)
default Either<L,R>	Either.or(Producer<Kind<Either<L,?>,R>> orElse)
default Option<T>	Option.or(Producer<Kind<Option<?>,T>> orElse)
default Try<T>	Try.or(Producer<Kind<Try<?>,T>> orElse)
default Validation<E,T>	Validation.or(Producer<Kind<Validation<E,?>,T>> orElse)

Constructor parameters in com.github.tonivade.purefun.type with type arguments of type Kind

Modifier	Constructor	Description
private	Defer(Producer<? extends Kind<Eval<?>,? extends A>> deferred)
private	FlatMapped(Producer<? extends Kind<Eval<?>,? extends A>> start, Function1<? super A,? extends Kind<Eval<?>,? extends B>> run)
private	FlatMapped(Producer<? extends Kind<Eval<?>,? extends A>> start, Function1<? super A,? extends Kind<Eval<?>,? extends B>> run)

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

Classes in com.github.tonivade.purefun.typeclasses with type parameters of type Kind

Modifier and Type	Class	Description
(package private) class	AbstractApply<F extends Kind<F,?>,A>
(package private) class	AbstractFlatMap<F extends Kind<F,?>,A,B>
interface	Alternative<F extends Kind<F,?>>
interface	Applicative<F extends Kind<F,?>>
static final record	Applicative.Map2<F extends Kind<F,?>,A,B>
static final record	Applicative.Map3<F extends Kind<F,?>,A,B,C>
static final record	Applicative.Map4<F extends Kind<F,?>,A,B,C,D>
static final record	Applicative.Map5<F extends Kind<F,?>,A,B,C,D,E>
interface	ApplicativeError<F extends Kind<F,?>,E>
final class	Apply1<F extends Kind<F,?>,A>
final class	Apply2<F extends Kind<F,?>,A,B>
final class	Apply3<F extends Kind<F,?>,A,B,C>
final class	Apply4<F extends Kind<F,?>,A,B,C,D>
final class	Apply5<F extends Kind<F,?>,A,B,C,D,E>
interface	Async<F extends Kind<F,?>>
interface	Bracket<F extends Kind<F,?>,E>
interface	Comonad<F extends Kind<F,?>>
(package private) interface	ComposedAlternative<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedAlternative<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedApplicative<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedApplicative<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedContravariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedContravariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedContravariantCovariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedContravariantCovariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedCovariantContravariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedCovariantContravariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedFoldable<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedFoldable<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedFunctor<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedFunctor<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedInvariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedInvariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedInvariantContravariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedInvariantContravariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedInvariantCovariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedInvariantCovariant<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedMonoidK<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedMonoidK<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedSemigroupK<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedSemigroupK<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedTraverse<F extends Kind<F,?>,G extends Kind<G,?>>
(package private) interface	ComposedTraverse<F extends Kind<F,?>,G extends Kind<G,?>>
interface	Concurrent<F extends Kind<F,?>>
interface	Console<F extends Kind<F,?>>
interface	Contravariant<F extends Kind<F,?>>
interface	Defer<F extends Kind<F,?>>
interface	Fiber<F extends Kind<F,?>,A>
final class	FlatMap1<F extends Kind<F,?>,A>
final class	FlatMap2<F extends Kind<F,?>,A,B>
final class	FlatMap3<F extends Kind<F,?>,A,B,C>
final class	FlatMap4<F extends Kind<F,?>,A,B,C,D>
final class	FlatMap5<F extends Kind<F,?>,A,B,C,D,E>
interface	Foldable<F extends Kind<F,?>>
interface	For<F extends Kind<F,?>>
static final record	For.Apply<F extends Kind<F,?>>
static final record	For.FlatMap<F extends Kind<F,?>>
interface	FunctionK<F extends Kind<F,?>,G extends Kind<G,?>>
interface	FunctionK<F extends Kind<F,?>,G extends Kind<G,?>>
interface	Functor<F extends Kind<F,?>>
interface	InjectK<F extends Kind<F,?>,G extends Kind<G,?>>
interface	InjectK<F extends Kind<F,?>,G extends Kind<G,?>>
class	Instance<F extends Kind<F,?>>
interface	Invariant<F extends Kind<F,?>>
interface	Monad<F extends Kind<F,?>>
interface	MonadDefer<F extends Kind<F,?>>
(package private) final class	MonadDeferReference<F extends Kind<F,?>,A>
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>
interface	MonoidK<F extends Kind<F,?>>
interface	Nested<F extends Kind<F,?>,G extends Kind<G,?>>
interface	Nested<F extends Kind<F,?>,G extends Kind<G,?>>
interface	Parallel<F extends Kind<F,?>,G extends Kind<G,?>>
interface	Parallel<F extends Kind<F,?>,G extends Kind<G,?>>
interface	Reference<F extends Kind<F,?>,A>
(package private) final class	ReferenceMonadState<F extends Kind<F,?>,S>
final class	Resource<F extends Kind<F,?>,T>
interface	ResourceOf<F extends Kind<F,?>,T>
interface	Runtime<F extends Kind<F,?>>
interface	Schedule<F extends Kind<F,?>,A,B>
static interface	Schedule.Of<F extends Kind<F,?>>
static interface	Schedule.Update<F extends Kind<F,?>,S,A>
(package private) final class	ScheduleImpl<F extends Kind<F,?>,S,A,B>
interface	ScheduleOf<F extends Kind<F,?>,A,B>
interface	Selective<F extends Kind<F,?>>
interface	Semigroupal<F extends Kind<F,?>>
interface	SemigroupK<F extends Kind<F,?>>
interface	Timer<F extends Kind<F,?>>
interface	Traverse<F extends Kind<F,?>>
interface	TupleK<F extends Kind<F,?>>
final class	TupleK1<F extends Kind<F,?>,A>
final class	TupleK2<F extends Kind<F,?>,A,B>
final class	TupleK3<F extends Kind<F,?>,A,B,C>
final class	TupleK4<F extends Kind<F,?>,A,B,C,D>
final class	TupleK5<F extends Kind<F,?>,A,B,C,D,E>

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

Modifier and Type	Interface	Description
interface	Monoid<T>
interface	MonoidOf<T>
interface	Nested<F extends Kind<F,?>,G extends Kind<G,?>>
interface	ResourceOf<F extends Kind<F,?>,T>
interface	Schedule<F extends Kind<F,?>,A,B>
interface	ScheduleOf<F extends Kind<F,?>,A,B>

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

Modifier and Type	Class	Description
final class	Resource<F extends Kind<F,?>,T>
(package private) final class	ScheduleImpl<F extends Kind<F,?>,S,A,B>

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

Modifier and Type	Field	Description
private final Kind<F,? extends A>	Applicative.Map2.fa	The field for the fa record component.
private final Kind<F,? extends A>	Applicative.Map3.fa	The field for the fa record component.
private final Kind<F,? extends A>	Applicative.Map4.fa	The field for the fa record component.
private final Kind<F,? extends A>	Applicative.Map5.fa	The field for the fa record component.
private final Kind<F,? extends B>	Applicative.Map2.fb	The field for the fb record component.
private final Kind<F,? extends B>	Applicative.Map3.fb	The field for the fb record component.
private final Kind<F,? extends B>	Applicative.Map4.fb	The field for the fb record component.
private final Kind<F,? extends B>	Applicative.Map5.fb	The field for the fb record component.
private final Kind<F,? extends C>	Applicative.Map3.fc	The field for the fc record component.
private final Kind<F,? extends C>	Applicative.Map4.fc	The field for the fc record component.
private final Kind<F,? extends C>	Applicative.Map5.fc	The field for the fc record component.
private final Kind<F,? extends D>	Applicative.Map4.fd	The field for the fd record component.
private final Kind<F,? extends D>	Applicative.Map5.fd	The field for the fd record component.
private final Kind<F,? extends E>	Applicative.Map5.fe	The field for the fe record component.
private final Kind<F,S>	ScheduleImpl.initial
private final Kind<F,Tuple2<T,Consumer1<? super T>>>	Resource.resource
private final Kind<F,A>	TupleK1.value1
private final Kind<F,A>	TupleK2.value1
private final Kind<F,A>	TupleK3.value1
private final Kind<F,A>	TupleK4.value1
private final Kind<F,A>	TupleK5.value1
private final Kind<F,B>	TupleK2.value2
private final Kind<F,B>	TupleK3.value2
private final Kind<F,B>	TupleK4.value2
private final Kind<F,B>	TupleK5.value2
private final Kind<F,C>	TupleK3.value3
private final Kind<F,C>	TupleK4.value3
private final Kind<F,C>	TupleK5.value3
private final Kind<F,D>	TupleK4.value4
private final Kind<F,D>	TupleK5.value4
private final Kind<F,E>	TupleK5.value5

Fields in com.github.tonivade.purefun.typeclasses with type parameters of type Kind

Modifier and Type	Field	Description
protected final Producer<? extends Kind<F,? extends A>>	AbstractApply.value
protected final Function1<? super A,? extends Kind<F,? extends B>>	AbstractFlatMap.value
private final Producer<? extends Kind<F,? extends A>>	Apply2.value1
private final Producer<? extends Kind<F,? extends A>>	Apply3.value1
private final Producer<? extends Kind<F,? extends A>>	Apply4.value1
private final Producer<? extends Kind<F,? extends A>>	Apply5.value1
private final Producer<? extends Kind<F,? extends A>>	FlatMap2.value1
private final Producer<? extends Kind<F,? extends A>>	FlatMap3.value1
private final Producer<? extends Kind<F,? extends A>>	FlatMap4.value1
private final Producer<? extends Kind<F,? extends A>>	FlatMap5.value1
private final Producer<? extends Kind<F,? extends B>>	Apply3.value2
private final Producer<? extends Kind<F,? extends B>>	Apply4.value2
private final Producer<? extends Kind<F,? extends B>>	Apply5.value2
private final Function1<? super A,? extends Kind<F,? extends B>>	FlatMap3.value2
private final Function1<? super A,? extends Kind<F,? extends B>>	FlatMap4.value2
private final Function1<? super A,? extends Kind<F,? extends B>>	FlatMap5.value2
private final Producer<? extends Kind<F,? extends C>>	Apply4.value3
private final Producer<? extends Kind<F,? extends C>>	Apply5.value3
private final Function1<? super B,? extends Kind<F,? extends C>>	FlatMap4.value3
private final Function1<? super B,? extends Kind<F,? extends C>>	FlatMap5.value3
private final Producer<? extends Kind<F,? extends D>>	Apply5.value4
private final Function1<? super C,? extends Kind<F,? extends D>>	FlatMap5.value4

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

Modifier and Type	Method	Description
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.allS(Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition, G... reified)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.allS(Foldable<G> foldable, Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition)
default <A extends Kind<A, ?>> FunctionK<F,A>	FunctionK.andThen(FunctionK<G,A> after)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.anyS(Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition, G... reified)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.anyS(Foldable<G> foldable, Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition)
static <F extends Kind<F, ?>> Applicative<F>	Instances.applicative(F... reified)
static <F extends Kind<F, ?>> Applicative<F>	Instances.applicative(Class<F> type, Object... params)
static <F extends Kind<F, ?>, E> ApplicativeError<F,E>	Instances.applicativeError(F... reified)
static <F extends Kind<F, ?>, E> ApplicativeError<F,E>	Instances.applicativeError(Class<F> type, Object... params)
static <F extends Kind<F, ?>> Async<F>	Instances.async(F... reified)
static <F extends Kind<F, ?>> Async<F>	Instances.async(Class<F> type, Object... params)
static <F extends Kind<F, ?>> Comonad<F>	Instances.comonad(F... reified)
static <F extends Kind<F, ?>> Comonad<F>	Instances.comonad(Class<F> type, Object... params)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Alternative<Nested<F,G>>	Alternative.compose(Alternative<F> f, Alternative<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Alternative<Nested<F,G>>	Alternative.compose(Alternative<F> f, Alternative<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Applicative<Nested<F,G>>	Applicative.compose(Applicative<F> f, Applicative<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Applicative<Nested<F,G>>	Applicative.compose(Applicative<F> f, Applicative<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Contravariant<Nested<F,G>>	Contravariant.compose(Contravariant<F> f, Functor<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Contravariant<Nested<F,G>>	Contravariant.compose(Contravariant<F> f, Functor<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Contravariant<Nested<F,G>>	Contravariant.compose(Functor<F> f, Contravariant<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Contravariant<Nested<F,G>>	Contravariant.compose(Functor<F> f, Contravariant<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Foldable<Nested<F,G>>	Foldable.compose(Foldable<F> f, Foldable<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Foldable<Nested<F,G>>	Foldable.compose(Foldable<F> f, Foldable<G> g)
default <B extends Kind<B, ?>> FunctionK<B,G>	FunctionK.compose(FunctionK<B,F> before)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Functor<Nested<F,G>>	Functor.compose(Contravariant<F> f, Contravariant<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Functor<Nested<F,G>>	Functor.compose(Contravariant<F> f, Contravariant<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Functor<Nested<F,G>>	Functor.compose(Functor<F> f, Functor<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Functor<Nested<F,G>>	Functor.compose(Functor<F> f, Functor<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Invariant<Nested<F,G>>	Invariant.compose(Invariant<F> f, Contravariant<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Invariant<Nested<F,G>>	Invariant.compose(Invariant<F> f, Contravariant<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Invariant<Nested<F,G>>	Invariant.compose(Invariant<F> f, Functor<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Invariant<Nested<F,G>>	Invariant.compose(Invariant<F> f, Functor<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Invariant<Nested<F,G>>	Invariant.compose(Invariant<F> f, Invariant<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Invariant<Nested<F,G>>	Invariant.compose(Invariant<F> f, Invariant<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Traverse<Nested<F,G>>	Traverse.compose(Traverse<F> f, Traverse<G> g)
static <F extends Kind<F, ?>, G extends Kind<G, ?>> Traverse<Nested<F,G>>	Traverse.compose(Traverse<F> f, Traverse<G> g)
static <F extends Kind<F, ?>> Concurrent<F>	Instances.concurrent(F... reified)
static <F extends Kind<F, ?>> Concurrent<F>	Instances.concurrent(Class<F> type, Object... params)
static <F extends Kind<F, ?>> Console<F>	Instances.console(F... reified)
static <F extends Kind<F, ?>> Console<F>	Instances.console(Class<F> type, Object... params)
static <F extends Kind<F, ?>, A> Schedule<F,A,Duration>	Schedule.delayed(Schedule<F,A,Duration> schedule, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.doUntil(Matcher1<A> condition, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.doUntilM(Function1<A,Kind<F,Boolean>> condition, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.doWhile(Matcher1<A> condition, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.doWhileM(Function1<A,Kind<F,Boolean>> condition, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,Duration>	Schedule.exponential(Duration delay, double factor, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,Duration>	Schedule.exponential(Duration delay, F... reified)
private static <F extends Kind<F, ?>> Class<?>	Instance.findClass(Instance<F> instance)
<R extends Kind<F, ?>> R	AbstractApply.fix(Function<? super Kind<F,? extends A>,? extends R> fixer)
<R extends Kind<F, ?>> R	AbstractFlatMap.fix(Function<? super Kind<F,? extends B>,? extends R> fixer)
static <F extends Kind<F, ?>> Foldable<F>	Instances.foldable(F... reified)
static <F extends Kind<F, ?>> Foldable<F>	Instances.foldable(Class<F> type, Object... params)
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, ?>, A> Schedule<F,A,Integer>	Schedule.forever(F... reified)
static <F extends Kind<F, ?>, S> MonadState<F,S>	MonadState.from(MonadDefer<F> monad, S value)
static <F extends Kind<F, ?>, T extends AutoCloseable> Resource<F,T>	Resource.from(MonadDefer<F> monad, Kind<F,? extends T> acquire)
static <F extends Kind<F, ?>, T> Resource<F,T>	Resource.from(MonadDefer<F> monad, Kind<F,? extends T> acquire, Consumer1<? super T> release)
static <F extends Kind<F, ?>> Functor<F>	Instances.functor(F... reified)
static <F extends Kind<F, ?>> Functor<F>	Instances.functor(Class<F> type, Object... params)
private static <F extends Kind<F, ?>> Class<F>	Instances.getClassOf(F... reified)
static <F extends Kind<F, ?>> FunctionK<F,F>	FunctionK.identity()
static <F extends Kind<F, ?>> Parallel<F,F>	Parallel.identity(Monad<F> monad)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.identity(F... reified)
static <F extends Kind<F, ?>> InjectK<F,F>	InjectK.injectReflexive()
static <F extends Kind<F, ?>, A> Schedule<F,A,Duration>	Schedule.linear(Duration delay, F... reified)
private static <F extends Kind<F, ?>, T> T	Instance.load(Instance<F> instance, Class<?> typeClass, Object... args)
default <G extends Kind<G, ?>> Fiber<G,A>	Fiber.mapK(FunctionK<F,G> map)
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)
static <F extends Kind<F, ?>> MonadDefer<F>	Instances.monadDefer(F... reified)
static <F extends Kind<F, ?>> MonadDefer<F>	Instances.monadDefer(Class<F> type, Object... params)
static <F extends Kind<F, ?>, E> MonadError<F,E>	Instances.monadError(F... reified)
static <F extends Kind<F, ?>, E> MonadError<F,E>	Instances.monadError(Class<F> type, Object... params)
static <F extends Kind<F, ?>, R> MonadReader<F,R>	Instances.monadReader(F... reified)
static <F extends Kind<F, ?>, R> MonadReader<F,R>	Instances.monadReader(Class<F> type, Object... params)
static <F extends Kind<F, ?>, S> MonadState<F,S>	Instances.monadState(F... reified)
static <F extends Kind<F, ?>, S> MonadState<F,S>	Instances.monadState(Class<F> type, Object... params)
static <F extends Kind<F, ?>> MonadThrow<F>	Instances.monadThrow(F... reified)
static <F extends Kind<F, ?>> MonadThrow<F>	Instances.monadThrow(Class<F> type, Object... params)
static <F extends Kind<F, ?>, W> MonadWriter<F,W>	Instances.monadWriter(F... reified)
static <F extends Kind<F, ?>, W> MonadWriter<F,W>	Instances.monadWriter(Class<F> type, Object... params)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, A> Kind<Nested<F,G>,A>	Nested.nest(Kind<F,? extends Kind<G,? extends A>> unnested)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, A> Kind<Nested<F,G>,A>	Nested.nest(Kind<F,? extends Kind<G,? extends A>> unnested)
static <F extends Kind<F, ?>, A> Schedule<F,A,Unit>	Schedule.never(F... reified)
static <F extends Kind<F, ?>, A> Fiber<F,A>	Fiber.of(Kind<F,A> join, Kind<F,Unit> cancel)
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, ?>, 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, ?>, A> Reference<F,A>	Reference.of(MonadDefer<F> monadF, A value)
static <F extends Kind<F, ?>> Schedule.Of<F>	Schedule.of(MonadDefer<F> monad)
static <F extends Kind<F, ?>> Schedule.Of<F>	Schedule.of(F... reified)
static <F extends Kind<F, ?>> Schedule.Of<F>	Schedule.of(Class<F> type)
static <F extends Kind<F, ?>, S, A, B> ScheduleImpl<F,S,A,B>	ScheduleImpl.of(MonadDefer<F> monad, Kind<F,S> initial, Schedule.Update<F,S,A> update, Schedule.Extract<A,S,B> extract)
static <F extends Kind<F, ?>, A> TupleK1<F,A>	TupleK.of(Kind<F,A> value1)
static <F extends Kind<F, ?>, A, B> TupleK2<F,A,B>	TupleK.of(Kind<F,A> value1, Kind<F,B> value2)
static <F extends Kind<F, ?>, A, B, C> TupleK3<F,A,B,C>	TupleK.of(Kind<F,A> value1, Kind<F,B> value2, Kind<F,C> value3)
static <F extends Kind<F, ?>, A, B, C, D> TupleK4<F,A,B,C,D>	TupleK.of(Kind<F,A> value1, Kind<F,B> value2, Kind<F,C> value3, Kind<F,D> value4)
static <F extends Kind<F, ?>, A, B, C, D, E> TupleK5<F,A,B,C,D,E>	TupleK.of(Kind<F,A> value1, Kind<F,B> value2, Kind<F,C> value3, Kind<F,D> value4, Kind<F,E> value5)
static <F extends Kind<F, ?>, A> Schedule<F,A,Unit>	Schedule.once(F... reified)
default <T extends Kind<T, ?>, A> Kind<F,Kind<T,A>>	Parallel.parSequence(Traverse<T> traverse, Kind<T,? extends Kind<F,? extends A>> value)
default <T extends Kind<T, ?>, A, B> Kind<F,Kind<T,B>>	Parallel.parTraverse(Traverse<T> traverse, Kind<T,? extends A> value, Function1<? super A,? extends Kind<F,? extends B>> mapper)
static <F extends Kind<F, ?>, T> Resource<F,T>	Resource.pure(MonadDefer<F> monad, Kind<F,? extends T> acquire)
static <F extends Kind<F, ?>, A> Schedule<F,A,Integer>	Schedule.recurs(int times, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,Tuple2<Integer,Integer>>	Schedule.recursSpaced(Duration delay, int times, F... reified)
static <F extends Kind<F, ?>> Runtime<F>	Instances.runtime(F... reified)
static <F extends Kind<F, ?>> Runtime<F>	Instances.runtime(Class<F> type, Object... params)
static <F extends Kind<F, ?>> Selective<F>	Instances.selective(F... reified)
static <F extends Kind<F, ?>> Selective<F>	Instances.selective(Class<F> type, Object... params)
default <G extends Kind<G, ?>, T> Kind<G,Kind<F,T>>	Traverse.sequence(Applicative<G> applicative, Kind<F,? extends Kind<G,? extends T>> value)
static <F extends Kind<F, ?>, A> Schedule<F,A,Integer>	Schedule.spaced(Duration delay, F... reified)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	Schedule.succeed(B value, F... reified)
static <F extends Kind<F, ?>, T> Resource<F,T>	ResourceOf.toResource(Kind<Resource<F,?>,? extends T> value)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	ScheduleOf.toSchedule(Kind<Schedule<F,A,?>,? extends B> value)
default <H extends Kind<H, ?>, T, R> Kind<H,Kind<Nested<F,G>,R>>	ComposedTraverse.traverse(Applicative<H> applicative, Kind<Nested<F,G>,T> value, Function1<? super T,? extends Kind<H,? extends R>> mapper)
static <F extends Kind<F, ?>> Traverse<F>	Instances.traverse(F... reified)
static <F extends Kind<F, ?>> Traverse<F>	Instances.traverse(Class<F> type, Object... params)
<G extends Kind<G, ?>, T, R> Kind<G,Kind<F,R>>	Traverse.traverse(Applicative<G> applicative, Kind<F,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	Schedule.unfold(B initial, Operator1<B> next, F... reified)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	Schedule.unfoldM(Kind<F,B> initial, Function1<B,Kind<F,Either<Unit,B>>> next, F... reified)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, A> Kind<F,Kind<G,A>>	Nested.unnest(Kind<Nested<F,G>,? extends A> nested)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, A> Kind<F,Kind<G,A>>	Nested.unnest(Kind<Nested<F,G>,? extends A> nested)
static <F extends Kind<F, ?>> For.Apply<F>	For.with(Applicative<F> applicative)
static <F extends Kind<F, ?>, T> Apply1<F,T>	For.with(Applicative<F> applicative, Kind<F,? extends T> value1)
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)

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

Modifier and Type	Method	Description
default Kind<F,Boolean>	Selective.andS(Kind<F,Boolean> condition, Kind<F,Boolean> fa)
default <T, R> Kind<F,R>	Monad.andThen(Kind<F,? extends T> value, Producer<? extends Kind<F,? extends R>> next)
<T, R> Kind<F,R>	Applicative.ap(Kind<F,? extends T> value, Kind<F,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Nested<F,G>,R>	ComposedApplicative.ap(Kind<Nested<F,G>,? extends T> value, Kind<Nested<F,G>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<F,R>	Monad.ap(Kind<F,? extends T> value, Kind<F,? extends Function1<? super T,? extends R>> apply)
<R> Kind<F,R>	Applicative.Map2.apply(Function2<? super A,? super B,? extends R> apply)
<R> Kind<F,R>	Applicative.Map3.apply(Function3<? super A,? super B,? super C,? extends R> apply)
<R> Kind<F,R>	Applicative.Map4.apply(Function4<? super A,? super B,? super C,? super D,? extends R> apply)
<R> Kind<F,R>	Applicative.Map5.apply(Function5<? super A,? super B,? super C,? super D,? super E,? extends R> apply)
<R> Kind<F,R>	Apply1.apply(Function1<? super A,? extends R> combinator)
<R> Kind<F,R>	Apply2.apply(Function2<? super A,? super B,? extends R> combinator)
<R> Kind<F,R>	Apply3.apply(Function3<? super A,? super B,? super C,? extends R> combine)
<R> Kind<F,R>	Apply4.apply(Function4<? super A,? super B,? super C,? super D,? extends R> combine)
<R> Kind<F,R>	Apply5.apply(Function5<A,B,C,D,E,R> combine)
<R> Kind<F,R>	FlatMap2.apply(Function2<? super A,? super B,? extends R> combine)
<R> Kind<F,R>	FlatMap3.apply(Function3<? super A,? super B,? super C,? extends R> combine)
<R> Kind<F,R>	FlatMap4.apply(Function4<A,B,C,D,R> combine)
<R> Kind<F,R>	FlatMap5.apply(Function5<A,B,C,D,E,R> combine)
<T> Kind<G,T>	FunctionK.apply(Kind<F,? extends T> from)
Kind<F,Tuple1<A>>	TupleK1.apply(Applicative<F> applicative)
final Kind<F,Tuple1<A>>	TupleK1.apply(F... reified)
Kind<F,Tuple2<A,B>>	TupleK2.apply(Applicative<F> applicative)
final Kind<F,Tuple2<A,B>>	TupleK2.apply(F... reified)
Kind<F,Tuple3<A,B,C>>	TupleK3.apply(Applicative<F> applicative)
final Kind<F,Tuple3<A,B,C>>	TupleK3.apply(F... reified)
Kind<F,Tuple4<A,B,C,D>>	TupleK4.apply(Applicative<F> applicative)
final Kind<F,Tuple4<A,B,C,D>>	TupleK4.apply(F... reified)
Kind<F,Tuple5<A,B,C,D,E>>	TupleK5.apply(Applicative<F> applicative)
final Kind<F,Tuple5<A,B,C,D,E>>	TupleK5.apply(F... reified)
Kind<F,R>	MonadReader.ask()
default <A> Kind<F,A>	Async.async(Consumer1<Consumer1<? super Try<? extends A>>> consumer)
<A> Kind<F,A>	Async.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<F,Unit>> consumer)
default <A> Kind<F,Either<E,A>>	ApplicativeError.attempt(Kind<F,A> value)
default <A extends AutoCloseable, B> Kind<F,B>	Bracket.bracket(Kind<F,? extends A> acquire, Function1<? super A,? extends Kind<F,? extends B>> use)
default <A, B> Kind<F,B>	Bracket.bracket(Kind<F,? extends A> acquire, Function1<? super A,? extends Kind<F,? extends B>> use, Consumer1<? super A> release)
<A, B> Kind<F,B>	Bracket.bracket(Kind<F,? extends A> acquire, Function1<? super A,? extends Kind<F,? extends B>> use, Function1<? super A,? extends Kind<F,Unit>> release)
default <A, B, C> Kind<F,C>	Selective.branch(Kind<F,Either<A,B>> value, Kind<F,Function1<? super A,? extends C>> applyA, Kind<F,Function1<? super B,? extends C>> applyB)
Kind<F,Unit>	Fiber.cancel()
default <A> Kind<F,A>	Concurrent.cancellable(Function1<Consumer1<? super Try<? extends A>>,Kind<F,Unit>> callback)
default <A> Kind<F,A>	MonadWriter.censor(Kind<F,? extends A> value, Operator1<W> mapper)
<A, B> Kind<F,B>	Comonad.coflatMap(Kind<F,? extends A> value, Function1<? super Kind<F,? extends A>,? extends B> map)
default <A> Kind<F,Kind<F,A>>	Comonad.coflatten(Kind<F,? extends A> value)
default <T> Kind<Nested<F,G>,T>	ComposedSemigroupK.combineK(Kind<Nested<F,G>,? extends T> t1, Kind<Nested<F,G>,? extends T> t2)
<T> Kind<F,T>	SemigroupK.combineK(Kind<F,? extends T> t1, Kind<F,? extends T> t2)
default <A, B> Kind<Nested<F,G>,B>	ComposedContravariantCovariant.contramap(Kind<Nested<F,G>,? extends A> value, Function1<? super B,? extends A> map)
default <A, B> Kind<Nested<F,G>,B>	ComposedCovariantContravariant.contramap(Kind<Nested<F,G>,? extends A> value, Function1<? super B,? extends A> map)
<A, B> Kind<F,B>	Contravariant.contramap(Kind<F,? extends A> value, Function1<? super B,? extends A> map)
default Kind<F,Long>	MonadDefer.currentNanos()
Kind<F,Long>	Timer.currentNanos()
<A> Kind<F,A>	Defer.defer(Producer<? extends Kind<F,? extends A>> defer)
default <A> Kind<F,A>	MonadError.ensure(Kind<F,A> value, Producer<E> error, Matcher1<A> matcher)
default Kind<F,Unit>	MonadDefer.exec(CheckedRunnable later)
Kind<F,? extends A>	Applicative.Map2.fa()	Returns the value of the fa record component.
Kind<F,? extends A>	Applicative.Map3.fa()	Returns the value of the fa record component.
Kind<F,? extends A>	Applicative.Map4.fa()	Returns the value of the fa record component.
Kind<F,? extends A>	Applicative.Map5.fa()	Returns the value of the fa record component.
Kind<F,? extends B>	Applicative.Map2.fb()	Returns the value of the fb record component.
Kind<F,? extends B>	Applicative.Map3.fb()	Returns the value of the fb record component.
Kind<F,? extends B>	Applicative.Map4.fb()	Returns the value of the fb record component.
Kind<F,? extends B>	Applicative.Map5.fb()	Returns the value of the fb record component.
Kind<F,? extends C>	Applicative.Map3.fc()	Returns the value of the fc record component.
Kind<F,? extends C>	Applicative.Map4.fc()	Returns the value of the fc record component.
Kind<F,? extends C>	Applicative.Map5.fc()	Returns the value of the fc record component.
Kind<F,? extends D>	Applicative.Map4.fd()	Returns the value of the fd record component.
Kind<F,? extends D>	Applicative.Map5.fd()	Returns the value of the fd record component.
Kind<F,? extends E>	Applicative.Map5.fe()	Returns the value of the fe record component.
default <A, B> Kind<F,A>	Applicative.first(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
<T, R> Kind<F,R>	Monad.flatMap(Kind<F,? extends T> value, Function1<? super T,? extends Kind<F,? extends R>> map)
<T, R> Kind<F,R>	ReferenceMonadState.flatMap(Kind<F,? extends T> value, Function1<? super T,? extends Kind<F,? extends R>> map)
default <T> Kind<F,T>	Monad.flatten(Kind<F,Kind<F,? extends T>> value)
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)
<A> Kind<F,Fiber<F,A>>	Concurrent.fork(Kind<F,? extends A> value)
default <A> Kind<F,A>	ApplicativeError.fromEither(Either<E,? extends A> value)
default <A> Kind<F,A>	MonadThrow.fromTry(Try<? extends A> value)
Kind<F,A>	MonadDeferReference.get()
Kind<F,S>	MonadState.get()
Kind<F,A>	Reference.get()
Kind<F,S>	ReferenceMonadState.get()
Kind<F,A>	TupleK1.get1()
Kind<F,A>	TupleK2.get1()
Kind<F,A>	TupleK3.get1()
Kind<F,A>	TupleK4.get1()
Kind<F,A>	TupleK5.get1()
Kind<F,B>	TupleK2.get2()
Kind<F,B>	TupleK3.get2()
Kind<F,B>	TupleK4.get2()
Kind<F,B>	TupleK5.get2()
Kind<F,C>	TupleK3.get3()
Kind<F,C>	TupleK4.get3()
Kind<F,C>	TupleK5.get3()
Kind<F,D>	TupleK4.get4()
Kind<F,D>	TupleK5.get4()
Kind<F,E>	TupleK5.get5()
Kind<F,A>	MonadDeferReference.getAndSet(A newValue)
Kind<F,A>	Reference.getAndSet(A newValue)
Kind<F,A>	MonadDeferReference.getAndUpdate(Operator1<A> update)
Kind<F,A>	Reference.getAndUpdate(Operator1<A> update)
default <A> Kind<F,A>	ApplicativeError.handleError(Kind<F,A> value, Function1<? super E,? extends A> handler)
<A> Kind<F,A>	ApplicativeError.handleErrorWith(Kind<F,A> value, Function1<? super E,? extends Kind<F,? extends A>> handler)
default <A> Kind<F,A>	Selective.ifS(Kind<F,Boolean> condition, Kind<F,? extends A> left, Kind<F,? extends A> right)
default <A, B> Kind<Nested<F,G>,B>	ComposedInvariant.imap(Kind<Nested<F,G>,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<Nested<F,G>,B>	ComposedInvariantContravariant.imap(Kind<Nested<F,G>,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<Nested<F,G>,B>	ComposedInvariantCovariant.imap(Kind<Nested<F,G>,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<F,B>	Contravariant.imap(Kind<F,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<F,B>	Functor.imap(Kind<F,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
<A, B> Kind<F,B>	Invariant.imap(Kind<F,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<Monoid<?>,B>	MonoidInvariant.imap(Kind<Monoid<?>,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
Kind<F,S>	ScheduleImpl.initial()
<T> Kind<G,T>	InjectK.inject(Kind<F,? extends T> value)
default <A> Kind<F,A>	MonadState.inspect(Function1<? super S,? extends A> mapper)
Kind<F,A>	Fiber.join()
default <A, B> Kind<F,B>	Applicative.last(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
default <A> Kind<F,A>	MonadDefer.later(Producer<? extends A> later)
<A> Kind<F,Tuple2<W,A>>	MonadWriter.listen(Kind<F,? extends A> value)
default <A, B> Kind<F,Tuple2<B,A>>	MonadWriter.listens(Kind<F,? extends A> value, Function1<? super W,? extends B> mapper)
default <T, R> Kind<F,R>	Applicative.map(Kind<F,? extends T> value, Function1<? super T,? extends R> map)
default <A, B> Kind<Nested<F,G>,B>	ComposedContravariant.map(Kind<Nested<F,G>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> Kind<Nested<F,G>,R>	ComposedFunctor.map(Kind<Nested<F,G>,? extends T> value, Function1<? super T,? extends R> map)
<T, R> Kind<F,R>	Functor.map(Kind<F,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Kind<F,R>	Monad.map(Kind<F,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Kind<F,R>	Traverse.map(Kind<F,? extends T> value, Function1<? super T,? extends R> map)
default <A, B, R> Kind<F,R>	Applicative.mapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Function2<? super A,? super B,? extends R> mapper)
default <A, B, C, R> Kind<F,R>	Applicative.mapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Function3<? super A,? super B,? super C,? extends R> mapper)
default <A, B, C, D, R> Kind<F,R>	Applicative.mapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd, Function4<? super A,? super B,? super C,? super D,? extends R> mapper)
default <A, B, C, D, E, R> Kind<F,R>	Applicative.mapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd, Kind<F,? extends E> fe, Function5<? super A,? super B,? super C,? super D,? super E,? extends R> mapper)
<B> Kind<F,B>	MonadDeferReference.modify(Function1<A,Tuple2<B,A>> change)
default Kind<F,Unit>	MonadState.modify(Operator1<S> mapper)
<B> Kind<F,B>	Reference.modify(Function1<A,Tuple2<B,A>> change)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, A> Kind<Nested<F,G>,A>	Nested.nest(Kind<F,? extends Kind<G,? extends A>> unnested)
default Kind<F,Boolean>	Selective.orS(Kind<F,Boolean> condition, Kind<F,Boolean> fa)
<A> Kind<G,A>	Parallel.parallel(Kind<F,? extends A> value)
default <A, B> Kind<F,B>	Parallel.parAp(Kind<F,? extends A> fa, Kind<F,? extends Function1<? super A,? extends B>> apply)
default <A, B, R> Kind<F,R>	Parallel.parMapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Function2<? super A,? super B,? extends R> mapper)
default <A, B, C, R> Kind<F,R>	Parallel.parMapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Function3<? super A,? super B,? super C,? extends R> mapper)
default <A, B, C, D, R> Kind<F,R>	Parallel.parMapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd, Function4<? super A,? super B,? super C,? super D,? extends R> mapper)
default <A, B, C, D, E, R> Kind<F,R>	Parallel.parMapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd, Kind<F,? extends E> fe, Function5<? super A,? super B,? super C,? super D,? super E,? extends R> mapper)
default <T extends Kind<T, ?>, A> Kind<F,Kind<T,A>>	Parallel.parSequence(Traverse<T> traverse, Kind<T,? extends Kind<F,? extends A>> value)
default <T extends Kind<T, ?>, A, B> Kind<F,Kind<T,B>>	Parallel.parTraverse(Traverse<T> traverse, Kind<T,? extends A> value, Function1<? super A,? extends Kind<F,? extends B>> mapper)
<A> Kind<F,A>	MonadWriter.pass(Kind<F,Tuple2<Operator1<W>,A>> value)
default Kind<F,Unit>	Console.printf(String template, Object... args)
default Kind<F,Unit>	Console.println(Object text, Object... args)
Kind<F,Unit>	Console.println(String text)
<A, B> Kind<F,Tuple2<A,B>>	Semigroupal.product(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
<T> Kind<F,T>	Applicative.pure(T value)
default <T> Kind<Nested<F,G>,T>	ComposedApplicative.pure(T value)
<T> Kind<F,T>	ReferenceMonadState.pure(T value)
default <A, B> Kind<F,Either<A,B>>	Concurrent.race(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
<A, B> Kind<F,Either<Tuple2<A,Fiber<F,B>>,Tuple2<Fiber<F,A>,B>>>	Concurrent.racePair(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
<A> Kind<F,A>	ApplicativeError.raiseError(E error)
default <A> Kind<F,A>	MonadReader.reader(Function1<? super R,? extends A> mapper)
Kind<F,String>	Console.readln()
default <A> Kind<F,A>	ApplicativeError.recover(Kind<F,A> value, PartialFunction1<? super E,? extends A> handler)
default <A> Kind<F,A>	ApplicativeError.recoverWith(Kind<F,A> value, PartialFunction1<? super E,? extends Kind<F,? extends A>> handler)
default <A, B> Kind<F,B>	MonadError.repeat(Kind<F,A> value, Schedule<F,A,B> schedule)
private <A, B, C, S> Kind<F,Either<C,B>>	MonadError.repeat(Kind<F,A> value, ScheduleImpl<F,S,A,B> schedule, Function2<E,Option<B>,Kind<F,C>> orElse)
default <A, B> Kind<F,B>	MonadError.repeatOrElse(Kind<F,A> value, Schedule<F,A,B> schedule, Function2<E,Option<B>,Kind<F,B>> orElse)
default <A, B, C> Kind<F,Either<C,B>>	MonadError.repeatOrElseEither(Kind<F,A> value, Schedule<F,A,B> schedule, Function2<E,Option<B>,Kind<F,C>> orElse)
default <A, B> Kind<F,A>	MonadError.retry(Kind<F,A> value, Schedule<F,E,B> schedule)
private <A, B, S> Kind<F,Either<B,A>>	MonadError.retry(Kind<F,A> value, ScheduleImpl<F,S,E,S> schedule, Function2<E,S,Kind<F,B>> orElse)
default <A, B> Kind<F,A>	MonadError.retryOrElse(Kind<F,A> value, Schedule<F,E,B> schedule, Function2<E,B,Kind<F,A>> orElse)
default <A, B, C> Kind<F,Either<B,A>>	MonadError.retryOrElseEither(Kind<F,A> value, Schedule<F,E,C> schedule, Function2<E,C,Kind<F,B>> orElse)
<R> Kind<F,R>	AbstractApply.returns(R other)
<R> Kind<F,R>	AbstractFlatMap.returns(R other)
abstract Kind<F,A>	AbstractApply.run()
abstract Kind<F,B>	AbstractFlatMap.run()
Kind<F,A>	Apply1.run()
Kind<F,B>	Apply2.run()
Kind<F,C>	Apply3.run()
Kind<F,D>	Apply4.run()
Kind<F,E>	Apply5.run()
Kind<F,A>	FlatMap1.run()
Kind<F,B>	FlatMap2.run()
Kind<F,C>	FlatMap3.run()
Kind<F,D>	FlatMap4.run()
Kind<F,E>	FlatMap5.run()
default <A, B> Kind<F,B>	Monad.select(Kind<F,Either<A,B>> value, Kind<F,Function1<? super A,? extends B>> apply)
<A, B> Kind<F,B>	Selective.select(Kind<F,Either<A,B>> value, Kind<F,Function1<? super A,? extends B>> apply)
private Kind<F,Either<Unit,Unit>>	Selective.selector(Kind<F,Boolean> condition)
default <G extends Kind<G, ?>, T> Kind<G,Kind<F,T>>	Traverse.sequence(Applicative<G> applicative, Kind<F,? extends Kind<G,? extends T>> value)
<A> Kind<F,A>	Parallel.sequential(Kind<G,? extends A> value)
Kind<F,Unit>	MonadDeferReference.set(A newValue)
Kind<F,Unit>	MonadState.set(S state)
Kind<F,Unit>	Reference.set(A newValue)
Kind<F,Unit>	ReferenceMonadState.set(S state)
Kind<F,Unit>	Timer.sleep(Duration duration)
default <A> Kind<F,A>	MonadState.state(Function1<? super S,Tuple2<S,? extends A>> mapper)
default <A, B, C> Kind<F,Tuple2<C,A>>	MonadDefer.summarized(Kind<F,A> value, Kind<F,B> summary, Function2<? super B,? super B,? extends C> combinator)
default <T, R> Kind<F,R>	Monad.tailRecM(T value, Function1<T,? extends Kind<F,Either<T,R>>> map)
default Kind<F,Unit>	MonadWriter.tell(W writer)
default <A> Kind<F,Tuple2<Duration,A>>	MonadDefer.timed(Kind<F,A> value)
default <H extends Kind<H, ?>, T, R> Kind<H,Kind<Nested<F,G>,R>>	ComposedTraverse.traverse(Applicative<H> applicative, Kind<Nested<F,G>,T> value, Function1<? super T,? extends Kind<H,? extends R>> mapper)
<G extends Kind<G, ?>, T, R> Kind<G,Kind<F,R>>	Traverse.traverse(Applicative<G> applicative, Kind<F,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <A, B> Kind<F,Tuple2<A,B>>	Applicative.tuple(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
default <A, B, C> Kind<F,Tuple3<A,B,C>>	Applicative.tuple(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc)
default <A, B, C, D> Kind<F,Tuple4<A,B,C,D>>	Applicative.tuple(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd)
default <A, B, C, D, E> Kind<F,Tuple5<A,B,C,D,E>>	Applicative.tuple(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd, Kind<F,? extends E> fe)
Kind<F,Tuple1<A>>	Apply1.tuple()
Kind<F,Tuple2<A,B>>	Apply2.tuple()
Kind<F,Tuple3<A,B,C>>	Apply3.tuple()
Kind<F,Tuple4<A,B,C,D>>	Apply4.tuple()
Kind<F,Tuple5<A,B,C,D,E>>	Apply5.tuple()
Kind<F,Tuple1<A>>	FlatMap1.tuple()
Kind<F,Tuple2<A,B>>	FlatMap2.tuple()
Kind<F,Tuple3<A,B,C>>	FlatMap3.tuple()
Kind<F,Tuple4<A,B,C,D>>	FlatMap4.tuple()
Kind<F,Tuple5<A,B,C,D,E>>	FlatMap5.tuple()
static <F extends Kind<F, ?>, G extends Kind<G, ?>, A> Kind<F,Kind<G,A>>	Nested.unnest(Kind<Nested<F,G>,? extends A> nested)
Kind<F,Either<Unit,S>>	Schedule.Update.update(A last, S state)
Kind<F,Either<Unit,S>>	ScheduleImpl.update(A last, S state)
Kind<F,A>	MonadDeferReference.updateAndGet(Operator1<A> update)
Kind<F,A>	Reference.updateAndGet(Operator1<A> update)
<R> Kind<F,R>	Resource.use(Function1<? super T,? extends Kind<F,? extends R>> use)
default Kind<F,Unit>	Selective.whenS(Kind<F,Boolean> condition, Kind<F,Unit> apply)
<A> Kind<F,A>	MonadWriter.writer(Tuple2<W,A> value)
default <T> Kind<Nested<F,G>,T>	ComposedMonoidK.zero()
<T> Kind<F,T>	MonoidK.zero()

Methods in com.github.tonivade.purefun.typeclasses that return types with arguments of type Kind

Modifier and Type	Method	Description
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.allS(Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition, G... reified)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.allS(Foldable<G> foldable, Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.anyS(Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition, G... reified)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.anyS(Foldable<G> foldable, Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition)
default <A> Resource<F,Kind<F,A>>	Concurrent.background(Kind<F,? extends A> acquire)
default <A> Kind<F,Kind<F,A>>	Comonad.coflatten(Kind<F,? extends A> value)
default <A, B> Function1<Kind<F,A>,Kind<F,B>>	Functor.lift(Function1<? super A,? extends B> function)
default <A, B> Function1<Kind<F,A>,Kind<F,B>>	Functor.lift(Function1<? super A,? extends B> function)
default <T extends Kind<T, ?>, A> Kind<F,Kind<T,A>>	Parallel.parSequence(Traverse<T> traverse, Kind<T,? extends Kind<F,? extends A>> value)
default <T extends Kind<T, ?>, A, B> Kind<F,Kind<T,B>>	Parallel.parTraverse(Traverse<T> traverse, Kind<T,? extends A> value, Function1<? super A,? extends Kind<F,? extends B>> mapper)
default <G extends Kind<G, ?>, T> Kind<G,Kind<F,T>>	Traverse.sequence(Applicative<G> applicative, Kind<F,? extends Kind<G,? extends T>> value)
Sequence<Kind<F,?>>	TupleK.toSequence()
Sequence<Kind<F,?>>	TupleK1.toSequence()
Sequence<Kind<F,?>>	TupleK2.toSequence()
Sequence<Kind<F,?>>	TupleK3.toSequence()
Sequence<Kind<F,?>>	TupleK4.toSequence()
Sequence<Kind<F,?>>	TupleK5.toSequence()
default <H extends Kind<H, ?>, T, R> Kind<H,Kind<Nested<F,G>,R>>	ComposedTraverse.traverse(Applicative<H> applicative, Kind<Nested<F,G>,T> value, Function1<? super T,? extends Kind<H,? extends R>> mapper)
<G extends Kind<G, ?>, T, R> Kind<G,Kind<F,R>>	Traverse.traverse(Applicative<G> applicative, Kind<F,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, A> Kind<F,Kind<G,A>>	Nested.unnest(Kind<Nested<F,G>,? extends A> nested)

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

Modifier and Type	Method	Description
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.allS(Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition, G... reified)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.allS(Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition, G... reified)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.allS(Foldable<G> foldable, Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition)
default Kind<F,Boolean>	Selective.andS(Kind<F,Boolean> condition, Kind<F,Boolean> fa)
default <T, R> Kind<F,R>	Monad.andThen(Kind<F,? extends T> value, Producer<? extends Kind<F,? extends R>> next)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.anyS(Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition, G... reified)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.anyS(Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition, G... reified)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.anyS(Foldable<G> foldable, Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition)
<T, R> Kind<F,R>	Applicative.ap(Kind<F,? extends T> value, Kind<F,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<Nested<F,G>,R>	ComposedApplicative.ap(Kind<Nested<F,G>,? extends T> value, Kind<Nested<F,G>,? extends Function1<? super T,? extends R>> apply)
default <T, R> Kind<F,R>	Monad.ap(Kind<F,? extends T> value, Kind<F,? extends Function1<? super T,? extends R>> apply)
static <F extends Kind<F, ?>> Applicative<F>	Instances.applicative(F... reified)
static <F extends Kind<F, ?>, E> ApplicativeError<F,E>	Instances.applicativeError(F... reified)
<T> Kind<G,T>	FunctionK.apply(Kind<F,? extends T> from)
final Kind<F,Tuple1<A>>	TupleK1.apply(F... reified)
final Kind<F,Tuple2<A,B>>	TupleK2.apply(F... reified)
final Kind<F,Tuple3<A,B,C>>	TupleK3.apply(F... reified)
final Kind<F,Tuple4<A,B,C,D>>	TupleK4.apply(F... reified)
final Kind<F,Tuple5<A,B,C,D,E>>	TupleK5.apply(F... reified)
static <F extends Kind<F, ?>> Async<F>	Instances.async(F... reified)
default <A> Kind<F,Either<E,A>>	ApplicativeError.attempt(Kind<F,A> value)
default <A> Resource<F,Kind<F,A>>	Concurrent.background(Kind<F,? extends A> acquire)
default <A extends AutoCloseable, B> Kind<F,B>	Bracket.bracket(Kind<F,? extends A> acquire, Function1<? super A,? extends Kind<F,? extends B>> use)
default <A, B> Kind<F,B>	Bracket.bracket(Kind<F,? extends A> acquire, Function1<? super A,? extends Kind<F,? extends B>> use, Consumer1<? super A> release)
<A, B> Kind<F,B>	Bracket.bracket(Kind<F,? extends A> acquire, Function1<? super A,? extends Kind<F,? extends B>> use, Function1<? super A,? extends Kind<F,Unit>> release)
default <A, B, C> Kind<F,C>	Selective.branch(Kind<F,Either<A,B>> value, Kind<F,Function1<? super A,? extends C>> applyA, Kind<F,Function1<? super B,? extends C>> applyB)
default <A> Kind<F,A>	MonadWriter.censor(Kind<F,? extends A> value, Operator1<W> mapper)
<A, B> Kind<F,B>	Comonad.coflatMap(Kind<F,? extends A> value, Function1<? super Kind<F,? extends A>,? extends B> map)
default <A> Kind<F,Kind<F,A>>	Comonad.coflatten(Kind<F,? extends A> value)
default <T> Kind<Nested<F,G>,T>	ComposedSemigroupK.combineK(Kind<Nested<F,G>,? extends T> t1, Kind<Nested<F,G>,? extends T> t2)
<T> Kind<F,T>	SemigroupK.combineK(Kind<F,? extends T> t1, Kind<F,? extends T> t2)
static <F extends Kind<F, ?>> Comonad<F>	Instances.comonad(F... reified)
static <F extends Kind<F, ?>> Concurrent<F>	Instances.concurrent(F... reified)
static <F extends Kind<F, ?>> Console<F>	Instances.console(F... reified)
default <A, B> Kind<Nested<F,G>,B>	ComposedContravariantCovariant.contramap(Kind<Nested<F,G>,? extends A> value, Function1<? super B,? extends A> map)
default <A, B> Kind<Nested<F,G>,B>	ComposedCovariantContravariant.contramap(Kind<Nested<F,G>,? extends A> value, Function1<? super B,? extends A> map)
<A, B> Kind<F,B>	Contravariant.contramap(Kind<F,? extends A> value, Function1<? super B,? extends A> map)
static <F extends Kind<F, ?>, A> Schedule<F,A,Duration>	Schedule.delayed(Schedule<F,A,Duration> schedule, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.doUntil(Matcher1<A> condition, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.doUntilM(Function1<A,Kind<F,Boolean>> condition, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.doWhile(Matcher1<A> condition, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.doWhileM(Function1<A,Kind<F,Boolean>> condition, F... reified)
default <A> Kind<F,A>	MonadError.ensure(Kind<F,A> value, Producer<E> error, Matcher1<A> matcher)
static <F extends Kind<F, ?>, A> Schedule<F,A,Duration>	Schedule.exponential(Duration delay, double factor, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,Duration>	Schedule.exponential(Duration delay, F... reified)
<A> A	Comonad.extract(Kind<F,? extends A> value)
default <A, B> Kind<F,A>	Applicative.first(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
<T, R> Kind<F,R>	Monad.flatMap(Kind<F,? extends T> value, Function1<? super T,? extends Kind<F,? extends R>> map)
<T, R> Kind<F,R>	ReferenceMonadState.flatMap(Kind<F,? extends T> value, Function1<? super T,? extends Kind<F,? extends R>> map)
default <T> Kind<F,T>	Monad.flatten(Kind<F,Kind<F,? extends T>> value)
default <A> A	Foldable.fold(Monoid<A> monoid, Kind<F,? extends A> value)
static <F extends Kind<F, ?>> Foldable<F>	Instances.foldable(F... reified)
default <A, B> B	ComposedFoldable.foldLeft(Kind<Nested<F,G>,? extends A> value, B initial, Function2<? super B,? super A,? extends B> mapper)
<A, B> B	Foldable.foldLeft(Kind<F,? extends A> value, B initial, Function2<? super B,? super A,? extends B> mapper)
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)
default <A, B> B	Foldable.foldMap(Monoid<B> monoid, Kind<F,? extends A> value, Function1<? super A,? extends B> mapper)
default <A, B> Eval<B>	ComposedFoldable.foldRight(Kind<Nested<F,G>,? extends A> value, Eval<? extends B> initial, Function2<? super A,? super Eval<? extends B>,? extends Eval<? extends B>> mapper)
<A, B> Eval<B>	Foldable.foldRight(Kind<F,? extends A> value, Eval<? extends B> initial, Function2<? super A,? super Eval<? extends B>,? extends Eval<? extends B>> mapper)
static <F extends Kind<F, ?>, A> Schedule<F,A,Integer>	Schedule.forever(F... reified)
<A> Kind<F,Fiber<F,A>>	Concurrent.fork(Kind<F,? extends A> value)
static <F extends Kind<F, ?>, T extends AutoCloseable> Resource<F,T>	Resource.from(MonadDefer<F> monad, Kind<F,? extends T> acquire)
static <F extends Kind<F, ?>, T> Resource<F,T>	Resource.from(MonadDefer<F> monad, Kind<F,? extends T> acquire, Consumer1<? super T> release)
static <F extends Kind<F, ?>> Functor<F>	Instances.functor(F... reified)
private static <F extends Kind<F, ?>> Class<F>	Instances.getClassOf(F... reified)
default <A> Kind<F,A>	ApplicativeError.handleError(Kind<F,A> value, Function1<? super E,? extends A> handler)
<A> Kind<F,A>	ApplicativeError.handleErrorWith(Kind<F,A> value, Function1<? super E,? extends Kind<F,? extends A>> handler)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.identity(F... reified)
default <A> Kind<F,A>	Selective.ifS(Kind<F,Boolean> condition, Kind<F,? extends A> left, Kind<F,? extends A> right)
default <A, B> Kind<Nested<F,G>,B>	ComposedInvariant.imap(Kind<Nested<F,G>,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<Nested<F,G>,B>	ComposedInvariantContravariant.imap(Kind<Nested<F,G>,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<Nested<F,G>,B>	ComposedInvariantCovariant.imap(Kind<Nested<F,G>,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<F,B>	Contravariant.imap(Kind<F,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<F,B>	Functor.imap(Kind<F,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
<A, B> Kind<F,B>	Invariant.imap(Kind<F,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<Monoid<?>,B>	MonoidInvariant.imap(Kind<Monoid<?>,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
<T> Kind<G,T>	InjectK.inject(Kind<F,? extends T> value)
default <A, B> Kind<F,B>	Applicative.last(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
static <F extends Kind<F, ?>, A> Schedule<F,A,Duration>	Schedule.linear(Duration delay, F... reified)
<A> Kind<F,Tuple2<W,A>>	MonadWriter.listen(Kind<F,? extends A> value)
default <A, B> Kind<F,Tuple2<B,A>>	MonadWriter.listens(Kind<F,? extends A> value, Function1<? super W,? extends B> mapper)
default <T, R> Kind<F,R>	Applicative.map(Kind<F,? extends T> value, Function1<? super T,? extends R> map)
default <A, B> Kind<Nested<F,G>,B>	ComposedContravariant.map(Kind<Nested<F,G>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> Kind<Nested<F,G>,R>	ComposedFunctor.map(Kind<Nested<F,G>,? extends T> value, Function1<? super T,? extends R> map)
<T, R> Kind<F,R>	Functor.map(Kind<F,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Kind<F,R>	Monad.map(Kind<F,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Kind<F,R>	Traverse.map(Kind<F,? extends T> value, Function1<? super T,? extends R> map)
<B> TupleK1<F,B>	TupleK1.map1(Function1<? super A,? extends B> mapper, F... reified)
<R> TupleK2<F,R,B>	TupleK2.map1(Function1<? super A,? extends R> mapper, F... reified)
<R> TupleK3<F,R,B,C>	TupleK3.map1(Function1<? super A,? extends R> mapper, F... reified)
<R> TupleK4<F,R,B,C,D>	TupleK4.map1(Function1<? super A,? extends R> mapper, F... reified)
<R> TupleK5<F,R,B,C,D,E>	TupleK5.map1(Function1<? super A,? extends R> mapper, F... reified)
<R> TupleK2<F,A,R>	TupleK2.map2(Function1<? super B,? extends R> mapper, F... reified)
<R> TupleK3<F,A,R,C>	TupleK3.map2(Function1<? super B,? extends R> mapper, F... reified)
<R> TupleK4<F,A,R,C,D>	TupleK4.map2(Function1<? super B,? extends R> mapper, F... reified)
<R> TupleK5<F,A,R,C,D,E>	TupleK5.map2(Function1<? super B,? extends R> mapper, F... reified)
<R> TupleK3<F,A,B,R>	TupleK3.map3(Function1<? super C,? extends R> mapper, F... reified)
<R> TupleK4<F,A,B,R,D>	TupleK4.map3(Function1<? super C,? extends R> mapper, F... reified)
<R> TupleK5<F,A,B,R,D,E>	TupleK5.map3(Function1<? super C,? extends R> mapper, F... reified)
<R> TupleK4<F,A,B,C,R>	TupleK4.map4(Function1<? super D,? extends R> mapper, F... reified)
<R> TupleK5<F,A,B,C,R,E>	TupleK5.map4(Function1<? super D,? extends R> mapper, F... reified)
<R> TupleK5<F,A,B,C,D,R>	TupleK5.map5(Function1<? super E,? extends R> mapper, F... reified)
default <A, B> Applicative.Map2<F,A,B>	Applicative.mapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
default <A, B, R> Kind<F,R>	Applicative.mapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Function2<? super A,? super B,? extends R> mapper)
default <A, B, C> Applicative.Map3<F,A,B,C>	Applicative.mapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc)
default <A, B, C, R> Kind<F,R>	Applicative.mapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Function3<? super A,? super B,? super C,? extends R> mapper)
default <A, B, C, D> Applicative.Map4<F,A,B,C,D>	Applicative.mapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd)
default <A, B, C, D, R> Kind<F,R>	Applicative.mapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd, Function4<? super A,? super B,? super C,? super D,? extends R> mapper)
default <A, B, C, D, E> Applicative.Map5<F,A,B,C,D,E>	Applicative.mapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd, Kind<F,? extends E> fe)
default <A, B, C, D, E, R> Kind<F,R>	Applicative.mapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd, Kind<F,? extends E> fe, Function5<? super A,? super B,? super C,? super D,? super E,? extends R> mapper)
static <F extends Kind<F, ?>> Monad<F>	Instances.monad(F... reified)
static <F extends Kind<F, ?>> MonadDefer<F>	Instances.monadDefer(F... reified)
static <F extends Kind<F, ?>, E> MonadError<F,E>	Instances.monadError(F... reified)
static <F extends Kind<F, ?>, R> MonadReader<F,R>	Instances.monadReader(F... reified)
static <F extends Kind<F, ?>, S> MonadState<F,S>	Instances.monadState(F... reified)
static <F extends Kind<F, ?>> MonadThrow<F>	Instances.monadThrow(F... reified)
static <F extends Kind<F, ?>, W> MonadWriter<F,W>	Instances.monadWriter(F... reified)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, A> Kind<Nested<F,G>,A>	Nested.nest(Kind<F,? extends Kind<G,? extends A>> unnested)
static <F extends Kind<F, ?>, A> Schedule<F,A,Unit>	Schedule.never(F... reified)
static <F extends Kind<F, ?>, A> Fiber<F,A>	Fiber.of(Kind<F,A> join, Kind<F,Unit> cancel)
static <F extends Kind<F, ?>> Schedule.Of<F>	Schedule.of(F... reified)
static <F extends Kind<F, ?>, S, A, B> ScheduleImpl<F,S,A,B>	ScheduleImpl.of(MonadDefer<F> monad, Kind<F,S> initial, Schedule.Update<F,S,A> update, Schedule.Extract<A,S,B> extract)
static <F extends Kind<F, ?>, A> TupleK1<F,A>	TupleK.of(Kind<F,A> value1)
static <F extends Kind<F, ?>, A, B> TupleK2<F,A,B>	TupleK.of(Kind<F,A> value1, Kind<F,B> value2)
static <F extends Kind<F, ?>, A, B, C> TupleK3<F,A,B,C>	TupleK.of(Kind<F,A> value1, Kind<F,B> value2, Kind<F,C> value3)
static <F extends Kind<F, ?>, A, B, C, D> TupleK4<F,A,B,C,D>	TupleK.of(Kind<F,A> value1, Kind<F,B> value2, Kind<F,C> value3, Kind<F,D> value4)
static <F extends Kind<F, ?>, A, B, C, D, E> TupleK5<F,A,B,C,D,E>	TupleK.of(Kind<F,A> value1, Kind<F,B> value2, Kind<F,C> value3, Kind<F,D> value4, Kind<F,E> value5)
static <F extends Kind<F, ?>, A> Schedule<F,A,Unit>	Schedule.once(F... reified)
default Kind<F,Boolean>	Selective.orS(Kind<F,Boolean> condition, Kind<F,Boolean> fa)
<A> Kind<G,A>	Parallel.parallel(Kind<F,? extends A> value)
default <A, B> Kind<F,B>	Parallel.parAp(Kind<F,? extends A> fa, Kind<F,? extends Function1<? super A,? extends B>> apply)
default <A, B, R> Kind<F,R>	Parallel.parMapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Function2<? super A,? super B,? extends R> mapper)
default <A, B, C, R> Kind<F,R>	Parallel.parMapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Function3<? super A,? super B,? super C,? extends R> mapper)
default <A, B, C, D, R> Kind<F,R>	Parallel.parMapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd, Function4<? super A,? super B,? super C,? super D,? extends R> mapper)
default <A, B, C, D, E, R> Kind<F,R>	Parallel.parMapN(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd, Kind<F,? extends E> fe, Function5<? super A,? super B,? super C,? super D,? super E,? extends R> mapper)
default <T> Future<T>	Runtime.parRun(Kind<F,T> value)
<T> Future<T>	Runtime.parRun(Kind<F,T> value, Executor executor)
default <T extends Kind<T, ?>, A> Kind<F,Kind<T,A>>	Parallel.parSequence(Traverse<T> traverse, Kind<T,? extends Kind<F,? extends A>> value)
default <T extends Kind<T, ?>, A, B> Kind<F,Kind<T,B>>	Parallel.parTraverse(Traverse<T> traverse, Kind<T,? extends A> value, Function1<? super A,? extends Kind<F,? extends B>> mapper)
<A> Kind<F,A>	MonadWriter.pass(Kind<F,Tuple2<Operator1<W>,A>> value)
<A, B> Kind<F,Tuple2<A,B>>	Semigroupal.product(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
static <F extends Kind<F, ?>, T> Resource<F,T>	Resource.pure(MonadDefer<F> monad, Kind<F,? extends T> acquire)
default <A, B> Kind<F,Either<A,B>>	Concurrent.race(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
<A, B> Kind<F,Either<Tuple2<A,Fiber<F,B>>,Tuple2<Fiber<F,A>,B>>>	Concurrent.racePair(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
default <A> Kind<F,A>	ApplicativeError.recover(Kind<F,A> value, PartialFunction1<? super E,? extends A> handler)
default <A> Kind<F,A>	ApplicativeError.recoverWith(Kind<F,A> value, PartialFunction1<? super E,? extends Kind<F,? extends A>> handler)
static <F extends Kind<F, ?>, A> Schedule<F,A,Integer>	Schedule.recurs(int times, F... reified)
static <F extends Kind<F, ?>, A> Schedule<F,A,Tuple2<Integer,Integer>>	Schedule.recursSpaced(Duration delay, int times, F... reified)
default <A> Option<A>	Foldable.reduce(Kind<F,? extends A> value, Operator2<A> combinator)
default <A, B> Kind<F,B>	MonadError.repeat(Kind<F,A> value, Schedule<F,A,B> schedule)
private <A, B, C, S> Kind<F,Either<C,B>>	MonadError.repeat(Kind<F,A> value, ScheduleImpl<F,S,A,B> schedule, Function2<E,Option<B>,Kind<F,C>> orElse)
default <A, B> Kind<F,B>	MonadError.repeatOrElse(Kind<F,A> value, Schedule<F,A,B> schedule, Function2<E,Option<B>,Kind<F,B>> orElse)
default <A, B, C> Kind<F,Either<C,B>>	MonadError.repeatOrElseEither(Kind<F,A> value, Schedule<F,A,B> schedule, Function2<E,Option<B>,Kind<F,C>> orElse)
default <A extends AutoCloseable> Resource<F,A>	MonadDefer.resource(Kind<F,A> acquire)
default <A> Resource<F,A>	MonadDefer.resource(Kind<F,A> acquire, Consumer1<A> release)
default <A, B> Kind<F,A>	MonadError.retry(Kind<F,A> value, Schedule<F,E,B> schedule)
private <A, B, S> Kind<F,Either<B,A>>	MonadError.retry(Kind<F,A> value, ScheduleImpl<F,S,E,S> schedule, Function2<E,S,Kind<F,B>> orElse)
default <A, B> Kind<F,A>	MonadError.retryOrElse(Kind<F,A> value, Schedule<F,E,B> schedule, Function2<E,B,Kind<F,A>> orElse)
default <A, B, C> Kind<F,Either<B,A>>	MonadError.retryOrElseEither(Kind<F,A> value, Schedule<F,E,C> schedule, Function2<E,C,Kind<F,B>> orElse)
<T> T	Runtime.run(Kind<F,T> value)
static <F extends Kind<F, ?>> Runtime<F>	Instances.runtime(F... reified)
default <A, B> Kind<F,B>	Monad.select(Kind<F,Either<A,B>> value, Kind<F,Function1<? super A,? extends B>> apply)
<A, B> Kind<F,B>	Selective.select(Kind<F,Either<A,B>> value, Kind<F,Function1<? super A,? extends B>> apply)
static <F extends Kind<F, ?>> Selective<F>	Instances.selective(F... reified)
private Kind<F,Either<Unit,Unit>>	Selective.selector(Kind<F,Boolean> condition)
default <G extends Kind<G, ?>, T> Kind<G,Kind<F,T>>	Traverse.sequence(Applicative<G> applicative, Kind<F,? extends Kind<G,? extends T>> value)
<A> Kind<F,A>	Parallel.sequential(Kind<G,? extends A> value)
static <F extends Kind<F, ?>, A> Schedule<F,A,Integer>	Schedule.spaced(Duration delay, F... reified)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	Schedule.succeed(B value, F... reified)
default <A, B, C> Kind<F,Tuple2<C,A>>	MonadDefer.summarized(Kind<F,A> value, Kind<F,B> summary, Function2<? super B,? super B,? extends C> combinator)
<B> Apply2<F,A,B>	Apply1.then(Kind<F,? extends B> next)
<C> Apply3<F,A,B,C>	Apply2.then(Kind<F,? extends C> next)
<D> Apply4<F,A,B,C,D>	Apply3.then(Kind<F,? extends D> next)
<E> Apply5<F,A,B,C,D,E>	Apply4.then(Kind<F,E> next)
<R> FlatMap2<F,A,R>	FlatMap1.then(Kind<F,? extends R> next)
<R> FlatMap3<F,A,B,R>	FlatMap2.then(Kind<F,? extends R> next)
<R> FlatMap4<F,A,B,C,R>	FlatMap3.then(Kind<F,? extends R> next)
<R> FlatMap5<F,A,B,C,D,R>	FlatMap4.then(Kind<F,R> next)
<T> Apply1<F,T>	For.Apply.then(Kind<F,T> next)
<T> FlatMap1<F,T>	For.FlatMap.then(Kind<F,T> next)
default <A> Kind<F,Tuple2<Duration,A>>	MonadDefer.timed(Kind<F,A> value)
static <T> Monoid<T>	MonoidOf.toMonoid(Kind<Monoid<?>,? extends T> value)
static <F extends Kind<F, ?>, T> Resource<F,T>	ResourceOf.toResource(Kind<Resource<F,?>,? extends T> value)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	ScheduleOf.toSchedule(Kind<Schedule<F,A,?>,? extends B> value)
default <H extends Kind<H, ?>, T, R> Kind<H,Kind<Nested<F,G>,R>>	ComposedTraverse.traverse(Applicative<H> applicative, Kind<Nested<F,G>,T> value, Function1<? super T,? extends Kind<H,? extends R>> mapper)
static <F extends Kind<F, ?>> Traverse<F>	Instances.traverse(F... reified)
<G extends Kind<G, ?>, T, R> Kind<G,Kind<F,R>>	Traverse.traverse(Applicative<G> applicative, Kind<F,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <A, B> Kind<F,Tuple2<A,B>>	Applicative.tuple(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
default <A, B, C> Kind<F,Tuple3<A,B,C>>	Applicative.tuple(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc)
default <A, B, C, D> Kind<F,Tuple4<A,B,C,D>>	Applicative.tuple(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd)
default <A, B, C, D, E> Kind<F,Tuple5<A,B,C,D,E>>	Applicative.tuple(Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd, Kind<F,? extends E> fe)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	Schedule.unfold(B initial, Operator1<B> next, F... reified)
default <A, B> Schedule<F,A,B>	Schedule.Of.unfoldM(Kind<F,B> initial, Function1<B,Kind<F,Either<Unit,B>>> next)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	Schedule.unfoldM(Kind<F,B> initial, Function1<B,Kind<F,Either<Unit,B>>> next, F... reified)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	Schedule.unfoldM(Kind<F,B> initial, Function1<B,Kind<F,Either<Unit,B>>> next, F... reified)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, A> Kind<F,Kind<G,A>>	Nested.unnest(Kind<Nested<F,G>,? extends A> nested)
default Kind<F,Unit>	Selective.whenS(Kind<F,Boolean> condition, Kind<F,Unit> apply)
static <F extends Kind<F, ?>, T> Apply1<F,T>	For.with(Applicative<F> applicative, Kind<F,? extends T> value1)
static <F extends Kind<F, ?>, T> FlatMap1<F,T>	For.with(Monad<F> monad, Kind<F,? extends T> value1)

Method parameters in com.github.tonivade.purefun.typeclasses with type arguments of type Kind

Modifier and Type	Method	Description
Schedule<F,A,B>	Schedule.addDelayM(Function1<B,Kind<F,Duration>> map)
Schedule<F,A,B>	ScheduleImpl.addDelayM(Function1<B,Kind<F,Duration>> map)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.allS(Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition, G... reified)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.allS(Foldable<G> foldable, Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition)
<B> Apply2<F,A,B>	Apply1.andThen(Producer<? extends Kind<F,? extends B>> producer)
<C> Apply3<F,A,B,C>	Apply2.andThen(Producer<? extends Kind<F,? extends C>> producer)
<D> Apply4<F,A,B,C,D>	Apply3.andThen(Producer<? extends Kind<F,? extends D>> producer)
<E> Apply5<F,A,B,C,D,E>	Apply4.andThen(Producer<? extends Kind<F,E>> producer)
<R> FlatMap2<F,A,R>	FlatMap1.andThen(Producer<? extends Kind<F,? extends R>> producer)
<R> FlatMap3<F,A,B,R>	FlatMap2.andThen(Producer<? extends Kind<F,? extends R>> producer)
<R> FlatMap4<F,A,B,C,R>	FlatMap3.andThen(Producer<? extends Kind<F,? extends R>> producer)
<R> FlatMap5<F,A,B,C,D,R>	FlatMap4.andThen(Producer<? extends Kind<F,R>> producer)
<T> FlatMap1<F,T>	For.FlatMap.andThen(Producer<? extends Kind<F,? extends T>> next)
default <T, R> Kind<F,R>	Monad.andThen(Kind<F,? extends T> value, Producer<? extends Kind<F,? extends R>> next)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.anyS(Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition, G... reified)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.anyS(Foldable<G> foldable, Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition)
<A> Kind<F,A>	Async.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<F,Unit>> consumer)
default <A extends AutoCloseable, B> Kind<F,B>	Bracket.bracket(Kind<F,? extends A> acquire, Function1<? super A,? extends Kind<F,? extends B>> use)
default <A, B> Kind<F,B>	Bracket.bracket(Kind<F,? extends A> acquire, Function1<? super A,? extends Kind<F,? extends B>> use, Consumer1<? super A> release)
<A, B> Kind<F,B>	Bracket.bracket(Kind<F,? extends A> acquire, Function1<? super A,? extends Kind<F,? extends B>> use, Function1<? super A,? extends Kind<F,Unit>> release)
default <A> Kind<F,A>	Concurrent.cancellable(Function1<Consumer1<? super Try<? extends A>>,Kind<F,Unit>> callback)
Schedule<F,A,B>	Schedule.check(Function2<A,B,Kind<F,Boolean>> condition)
Schedule<F,A,B>	ScheduleImpl.check(Function2<A,B,Kind<F,Boolean>> condition)
<A, B> Kind<F,B>	Comonad.coflatMap(Kind<F,? extends A> value, Function1<? super Kind<F,? extends A>,? extends B> map)
<A> Kind<F,A>	Defer.defer(Producer<? extends Kind<F,? extends A>> defer)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.doUntilM(Function1<A,Kind<F,Boolean>> condition, F... reified)
default <A> Schedule<F,A,A>	Schedule.Of.doUntilM(Function1<A,Kind<F,Boolean>> condition)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.doWhileM(Function1<A,Kind<F,Boolean>> condition, F... reified)
default <A> Schedule<F,A,A>	Schedule.Of.doWhileM(Function1<A,Kind<F,Boolean>> condition)
void	AbstractApply.end(Consumer1<? super Kind<F,A>> consumer)
void	AbstractFlatMap.end(Consumer1<? super Kind<F,B>> consumer)
<R extends Kind<F, ?>> R	AbstractApply.fix(Function<? super Kind<F,? extends A>,? extends R> fixer)
<R extends Kind<F, ?>> R	AbstractFlatMap.fix(Function<? super Kind<F,? extends B>,? extends R> fixer)
<R> FlatMap2<F,A,R>	FlatMap1.flatMap(Function1<? super A,? extends Kind<F,? extends R>> mapper)
<R> FlatMap3<F,A,B,R>	FlatMap2.flatMap(Function1<? super B,? extends Kind<F,? extends R>> mapper)
<R> FlatMap4<F,A,B,C,R>	FlatMap3.flatMap(Function1<? super C,? extends Kind<F,? extends R>> mapper)
<R> FlatMap5<F,A,B,C,D,R>	FlatMap4.flatMap(Function1<D,? extends Kind<F,R>> mapper)
<T, R> Kind<F,R>	Monad.flatMap(Kind<F,? extends T> value, Function1<? super T,? extends Kind<F,? extends R>> map)
<T, R> Kind<F,R>	ReferenceMonadState.flatMap(Kind<F,? extends T> value, Function1<? super T,? extends Kind<F,? extends R>> map)
<R> Resource<F,R>	Resource.flatMap(Function1<? super T,? extends Kind<Resource<F,?>,? extends R>> mapper)
default <T> Kind<F,T>	Monad.flatten(Kind<F,Kind<F,? extends T>> value)
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)
<Z> Schedule<F,A,Z>	Schedule.foldM(Z zero, Function2<? super Z,? super B,? extends Kind<F,Either<Unit,? extends Z>>> next)
<Z> Schedule<F,A,Z>	ScheduleImpl.foldM(Z zero, Function2<? super Z,? super B,? extends Kind<F,Either<Unit,? extends Z>>> next)
default void	TupleK.forEach(Consumer1<? super Kind<F,?>> consumer)
<A> Kind<F,A>	ApplicativeError.handleErrorWith(Kind<F,A> value, Function1<? super E,? extends Kind<F,? extends A>> handler)
static <F extends Kind<F, ?>, G extends Kind<G, ?>, A> Kind<Nested<F,G>,A>	Nested.nest(Kind<F,? extends Kind<G,? extends A>> unnested)
default <T> Future<Sequence<T>>	Runtime.parRun(Sequence<Kind<F,T>> values)
<T> Future<Sequence<T>>	Runtime.parRun(Sequence<Kind<F,T>> values, Executor executor)
default <T extends Kind<T, ?>, A> Kind<F,Kind<T,A>>	Parallel.parSequence(Traverse<T> traverse, Kind<T,? extends Kind<F,? extends A>> value)
default <T extends Kind<T, ?>, A, B> Kind<F,Kind<T,B>>	Parallel.parTraverse(Traverse<T> traverse, Kind<T,? extends A> value, Function1<? super A,? extends Kind<F,? extends B>> mapper)
default <A> Kind<F,A>	ApplicativeError.recoverWith(Kind<F,A> value, PartialFunction1<? super E,? extends Kind<F,? extends A>> handler)
private <A, B, C, S> Kind<F,Either<C,B>>	MonadError.repeat(Kind<F,A> value, ScheduleImpl<F,S,A,B> schedule, Function2<E,Option<B>,Kind<F,C>> orElse)
default <A, B> Kind<F,B>	MonadError.repeatOrElse(Kind<F,A> value, Schedule<F,A,B> schedule, Function2<E,Option<B>,Kind<F,B>> orElse)
default <A, B, C> Kind<F,Either<C,B>>	MonadError.repeatOrElseEither(Kind<F,A> value, Schedule<F,A,B> schedule, Function2<E,Option<B>,Kind<F,C>> orElse)
private <A, B, S> Kind<F,Either<B,A>>	MonadError.retry(Kind<F,A> value, ScheduleImpl<F,S,E,S> schedule, Function2<E,S,Kind<F,B>> orElse)
default <A, B> Kind<F,A>	MonadError.retryOrElse(Kind<F,A> value, Schedule<F,E,B> schedule, Function2<E,B,Kind<F,A>> orElse)
default <A, B, C> Kind<F,Either<B,A>>	MonadError.retryOrElseEither(Kind<F,A> value, Schedule<F,E,C> schedule, Function2<E,C,Kind<F,B>> orElse)
<T> Sequence<T>	Runtime.run(Sequence<Kind<F,T>> values)
default <G extends Kind<G, ?>, T> Kind<G,Kind<F,T>>	Traverse.sequence(Applicative<G> applicative, Kind<F,? extends Kind<G,? extends T>> value)
default <T, R> Kind<F,R>	Monad.tailRecM(T value, Function1<T,? extends Kind<F,Either<T,R>>> map)
default <H extends Kind<H, ?>, T, R> Kind<H,Kind<Nested<F,G>,R>>	ComposedTraverse.traverse(Applicative<H> applicative, Kind<Nested<F,G>,T> value, Function1<? super T,? extends Kind<H,? extends R>> mapper)
<G extends Kind<G, ?>, T, R> Kind<G,Kind<F,R>>	Traverse.traverse(Applicative<G> applicative, Kind<F,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <A, B> Schedule<F,A,B>	Schedule.Of.unfoldM(Kind<F,B> initial, Function1<B,Kind<F,Either<Unit,B>>> next)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	Schedule.unfoldM(Kind<F,B> initial, Function1<B,Kind<F,Either<Unit,B>>> next, F... reified)
Schedule<F,A,B>	Schedule.untilInputM(Function1<A,Kind<F,Boolean>> condition)
Schedule<F,A,B>	ScheduleImpl.untilInputM(Function1<A,Kind<F,Boolean>> condition)
Schedule<F,A,B>	Schedule.untilOutputM(Function1<B,Kind<F,Boolean>> condition)
Schedule<F,A,B>	ScheduleImpl.untilOutputM(Function1<B,Kind<F,Boolean>> condition)
<R> Kind<F,R>	Resource.use(Function1<? super T,? extends Kind<F,? extends R>> use)
default Schedule<F,A,B>	Schedule.whileInputM(Function1<A,Kind<F,Boolean>> condition)
default Schedule<F,A,B>	Schedule.whileOutputM(Function1<B,Kind<F,Boolean>> condition)

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

Modifier	Constructor	Description
	Map2(Applicative<F> instance, Kind<F,? extends A> fa, Kind<F,? extends B> fb)	Creates an instance of a Map2 record class.
	Map3(Applicative<F> instance, Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc)	Creates an instance of a Map3 record class.
	Map4(Applicative<F> instance, Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd)	Creates an instance of a Map4 record class.
	Map5(Applicative<F> instance, Kind<F,? extends A> fa, Kind<F,? extends B> fb, Kind<F,? extends C> fc, Kind<F,? extends D> fd, Kind<F,? extends E> fe)	Creates an instance of a Map5 record class.
(package private)	Resource(MonadDefer<F> monad, Kind<F,Tuple2<T,Consumer1<? super T>>> resource)
private	ScheduleImpl(MonadDefer<F> monad, Kind<F,S> initial, Schedule.Update<F,S,A> update, Schedule.Extract<A,S,B> extract)
	TupleK1(Kind<F,A> value1)
	TupleK2(Kind<F,A> value1, Kind<F,B> value2)
	TupleK3(Kind<F,A> value1, Kind<F,B> value2, Kind<F,C> value3)
	TupleK4(Kind<F,A> value1, Kind<F,B> value2, Kind<F,C> value3, Kind<F,D> value4)
	TupleK5(Kind<F,A> value1, Kind<F,B> value2, Kind<F,C> value3, Kind<F,D> value4, Kind<F,E> value5)

Constructor parameters in com.github.tonivade.purefun.typeclasses with type arguments of type Kind

Modifier	Constructor	Description
protected	AbstractApply(Applicative<F> applicative, Producer<? extends Kind<F,? extends A>> value)
protected	AbstractFlatMap(Monad<F> monad, Function1<? super A,? extends Kind<F,? extends B>> value)
(package private)	Apply1(Applicative<F> applicative, Producer<Kind<F,? extends A>> value)
(package private)	Apply2(Applicative<F> applicative, Producer<? extends Kind<F,? extends A>> value1, Producer<? extends Kind<F,? extends B>> value2)
(package private)	Apply3(Applicative<F> applicative, Producer<? extends Kind<F,? extends A>> value1, Producer<? extends Kind<F,? extends B>> value2, Producer<? extends Kind<F,? extends C>> value3)
(package private)	Apply4(Applicative<F> applicative, Producer<? extends Kind<F,? extends A>> value1, Producer<? extends Kind<F,? extends B>> value2, Producer<? extends Kind<F,? extends C>> value3, Producer<? extends Kind<F,? extends D>> value4)
(package private)	Apply5(Applicative<F> applicative, Producer<? extends Kind<F,? extends A>> value1, Producer<? extends Kind<F,? extends B>> value2, Producer<? extends Kind<F,? extends C>> value3, Producer<? extends Kind<F,? extends D>> value4, Producer<? extends Kind<F,? extends E>> value5)
(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)	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)	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)	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)	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)