Uses of Class
com.jnape.palatable.lambda.io.IO

Packages that use IO

Package	Description
com.jnape.palatable.lambda.adt
com.jnape.palatable.lambda.functions
com.jnape.palatable.lambda.functions.builtin.fn2
com.jnape.palatable.lambda.functions.builtin.fn3
com.jnape.palatable.lambda.io
com.jnape.palatable.lambda.monad.transformer.builtin
com.jnape.palatable.lambda.monoid.builtin
com.jnape.palatable.lambda.semigroup.builtin

Uses of IO in com.jnape.palatable.lambda.adt

Method parameters in com.jnape.palatable.lambda.adt with type arguments of type IO

Modifier and Type	Method	Description
Either<L,R>	Either.peek(Fn1<? super L, ? extends IO<?>> leftEffect, Fn1<? super R, ? extends IO<?>> rightEffect)	Deprecated. in favor of matching into an IO and explicitly running it
Either<L,R>	Either.peek(Fn1<? super R, ? extends IO<?>> effect)	Deprecated. in favor of matching into an IO and explicitly running it
final Maybe<A>	Maybe.peek(Fn1<? super A, ? extends IO<?>> effect)	Deprecated. in favor of matching into an IO and explicitly running it

Uses of IO in com.jnape.palatable.lambda.functions

Subinterfaces with type arguments of type IO in com.jnape.palatable.lambda.functions

Modifier and Type	Interface	Description
interface	Effect<A>	A function returning "no result", and therefore only useful as a side-effect.

Methods in com.jnape.palatable.lambda.functions that return IO

Modifier and Type	Method	Description
default IO<Unit>	Effect.apply(A a)	Invoke this function explosively with the given argument.
IO<Unit>	Effect.checkedApply(A a)

Method parameters in com.jnape.palatable.lambda.functions with type arguments of type IO

Modifier and Type	Method	Description
static <A> Effect<A>	Effect.effect(Fn1<? super A, ? extends IO<?>> fn)	Create an Effect from an Fn1 that yields an IO.

Uses of IO in com.jnape.palatable.lambda.functions.builtin.fn2

Classes in com.jnape.palatable.lambda.functions.builtin.fn2 that implement interfaces with type arguments of type IO

Modifier and Type	Class	Description
final class	Alter<A>	Given an Effect<A> and some A, produce an IO that, when run, performs the effect on A and returns it.
final class	Alter<A>	Given an Effect<A> and some A, produce an IO that, when run, performs the effect on A and returns it.
final class	AutoBracket<A extends AutoCloseable, B>	Given an IO yielding some AutoCloseable type A and a kleisli arrow from that type to a new IO of type B, attempt to provision the A, applying the body operation if provisioning was successful and ensuring that AutoCloseable.close() is called regardless of whether the body succeeds or fails.
final class	AutoBracket<A extends AutoCloseable, B>	Given an IO yielding some AutoCloseable type A and a kleisli arrow from that type to a new IO of type B, attempt to provision the A, applying the body operation if provisioning was successful and ensuring that AutoCloseable.close() is called regardless of whether the body succeeds or fails.
final class	AutoBracket<A extends AutoCloseable, B>	Given an IO yielding some AutoCloseable type A and a kleisli arrow from that type to a new IO of type B, attempt to provision the A, applying the body operation if provisioning was successful and ensuring that AutoCloseable.close() is called regardless of whether the body succeeds or fails.
final class	Peek<A, FA extends Functor<A,?>>	Deprecated. in favor of producing an IO from the given Functor and explicitly running it
final class	Peek2<A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>>	Deprecated. in favor of producing an IO from the given BoundedBifunctor and explicitly running it
final class	Peek2<A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>>	Deprecated. in favor of producing an IO from the given BoundedBifunctor and explicitly running it
final class	Until<A>	Given a predicate function for a value of some type A and an IO that yields a value of type A, produce an IO that repeatedly executes the original IO until the predicate returns true when applied to the yielded value.
final class	Until<A>	Given a predicate function for a value of some type A and an IO that yields a value of type A, produce an IO that repeatedly executes the original IO until the predicate returns true when applied to the yielded value.

Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return IO

Modifier and Type	Method	Description
static <A> IO<A>	Alter.alter(Effect<? super A> effect, A a)
static <A extends AutoCloseable, B> IO<B>	AutoBracket.autoBracket(IO<A> io, Fn1<? super A, ? extends IO<B>> bodyIO)
IO<A>	Alter.checkedApply(Fn1<? super A, ? extends IO<?>> effect, A a)
IO<B>	AutoBracket.checkedApply(IO<A> io, Fn1<? super A, ? extends IO<B>> bodyIO)
IO<A>	Until.checkedApply(Fn1<? super A, ? extends Boolean> pred, IO<A> io)
static <A> IO<A>	Until.until(Fn1<? super A, ? extends Boolean> pred, IO<A> io)

Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return types with arguments of type IO

Modifier and Type	Method	Description
static <A> Fn1<A,IO<A>>	Alter.alter(Effect<? super A> effect)
static <A extends AutoCloseable, B> Fn1<Fn1<? super A, ? extends IO<B>>, IO<B>>	AutoBracket.autoBracket(IO<A> io)
static <A extends AutoCloseable, B> Fn1<Fn1<? super A, ? extends IO<B>>, IO<B>>	AutoBracket.autoBracket(IO<A> io)
static <A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>> Fn2<Fn1<? super B, ? extends IO<?>>, FAB, FAB>	Peek2.peek2(Fn1<? super A, ? extends IO<?>> effectA)	Deprecated.
static <A> Fn1<IO<A>,IO<A>>	Until.until(Fn1<? super A, ? extends Boolean> pred)
static <A> Fn1<IO<A>,IO<A>>	Until.until(Fn1<? super A, ? extends Boolean> pred)

Methods in com.jnape.palatable.lambda.functions.builtin.fn2 with parameters of type IO

Modifier and Type	Method	Description
static <A extends AutoCloseable, B> Fn1<Fn1<? super A, ? extends IO<B>>, IO<B>>	AutoBracket.autoBracket(IO<A> io)
static <A extends AutoCloseable, B> IO<B>	AutoBracket.autoBracket(IO<A> io, Fn1<? super A, ? extends IO<B>> bodyIO)
IO<B>	AutoBracket.checkedApply(IO<A> io, Fn1<? super A, ? extends IO<B>> bodyIO)
IO<A>	Until.checkedApply(Fn1<? super A, ? extends Boolean> pred, IO<A> io)
static <A> IO<A>	Until.until(Fn1<? super A, ? extends Boolean> pred, IO<A> io)

Method parameters in com.jnape.palatable.lambda.functions.builtin.fn2 with type arguments of type IO

Modifier and Type	Method	Description
static <A extends AutoCloseable, B> IO<B>	AutoBracket.autoBracket(IO<A> io, Fn1<? super A, ? extends IO<B>> bodyIO)
IO<A>	Alter.checkedApply(Fn1<? super A, ? extends IO<?>> effect, A a)
IO<B>	AutoBracket.checkedApply(IO<A> io, Fn1<? super A, ? extends IO<B>> bodyIO)
FA	Peek.checkedApply(Fn1<? super A, ? extends IO<?>> effect, FA fa)	Deprecated.
FAB	Peek2.checkedApply(Fn1<? super A, ? extends IO<?>> effectA, Fn1<? super B, ? extends IO<?>> effectB, FAB fab)	Deprecated.
static <A, FA extends Functor<A,?>> Fn1<FA,FA>	Peek.peek(Fn1<? super A, ? extends IO<?>> effect)	Deprecated.
static <A, FA extends Functor<A,?>> FA	Peek.peek(Fn1<? super A, ? extends IO<?>> effect, FA fa)	Deprecated.
static <A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>> Fn2<Fn1<? super B, ? extends IO<?>>, FAB, FAB>	Peek2.peek2(Fn1<? super A, ? extends IO<?>> effectA)	Deprecated.
static <A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>> Fn1<FAB,FAB>	Peek2.peek2(Fn1<? super A, ? extends IO<?>> effectA, Fn1<? super B, ? extends IO<?>> effectB)	Deprecated.
static <A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>> FAB	Peek2.peek2(Fn1<? super A, ? extends IO<?>> effectA, Fn1<? super B, ? extends IO<?>> effectB, FAB fab)	Deprecated.

Uses of IO in com.jnape.palatable.lambda.functions.builtin.fn3

Classes in com.jnape.palatable.lambda.functions.builtin.fn3 that implement interfaces with type arguments of type IO

Modifier and Type	Class	Description
final class	Bracket<A,B>	Given an IO that yields some type A, a cleanup operation to run if a value of that type could be provisioned, and a kleisli arrow from that type to a new IO of type B, produce an IO<B> that, when run, will provision the A, flatMap it to B, and clean up the original value if it was produced in the first place.
final class	Bracket<A,B>	Given an IO that yields some type A, a cleanup operation to run if a value of that type could be provisioned, and a kleisli arrow from that type to a new IO of type B, produce an IO<B> that, when run, will provision the A, flatMap it to B, and clean up the original value if it was produced in the first place.
final class	Bracket<A,B>	Given an IO that yields some type A, a cleanup operation to run if a value of that type could be provisioned, and a kleisli arrow from that type to a new IO of type B, produce an IO<B> that, when run, will provision the A, flatMap it to B, and clean up the original value if it was produced in the first place.
final class	Bracket<A,B>	Given an IO that yields some type A, a cleanup operation to run if a value of that type could be provisioned, and a kleisli arrow from that type to a new IO of type B, produce an IO<B> that, when run, will provision the A, flatMap it to B, and clean up the original value if it was produced in the first place.

Methods in com.jnape.palatable.lambda.functions.builtin.fn3 that return IO

Modifier and Type	Method	Description
static <A,B> IO<B>	Bracket.bracket(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO, Fn1<? super A, ? extends IO<B>> bodyIO)
IO<B>	Bracket.checkedApply(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO, Fn1<? super A, ? extends IO<B>> bodyIO)

Methods in com.jnape.palatable.lambda.functions.builtin.fn3 that return types with arguments of type IO

Modifier and Type	Method	Description
static <A,B> Fn2<Fn1<? super A, ? extends IO<?>>, Fn1<? super A, ? extends IO<B>>, IO<B>>	Bracket.bracket(IO<A> io)
static <A,B> Fn2<Fn1<? super A, ? extends IO<?>>, Fn1<? super A, ? extends IO<B>>, IO<B>>	Bracket.bracket(IO<A> io)
static <A,B> Fn2<Fn1<? super A, ? extends IO<?>>, Fn1<? super A, ? extends IO<B>>, IO<B>>	Bracket.bracket(IO<A> io)
static <A,B> Fn1<Fn1<? super A, ? extends IO<B>>, IO<B>>	Bracket.bracket(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO)
static <A,B> Fn1<Fn1<? super A, ? extends IO<B>>, IO<B>>	Bracket.bracket(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO)

Methods in com.jnape.palatable.lambda.functions.builtin.fn3 with parameters of type IO

Modifier and Type	Method	Description
static <A,B> Fn2<Fn1<? super A, ? extends IO<?>>, Fn1<? super A, ? extends IO<B>>, IO<B>>	Bracket.bracket(IO<A> io)
static <A,B> Fn1<Fn1<? super A, ? extends IO<B>>, IO<B>>	Bracket.bracket(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO)
static <A,B> IO<B>	Bracket.bracket(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO, Fn1<? super A, ? extends IO<B>> bodyIO)
IO<B>	Bracket.checkedApply(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO, Fn1<? super A, ? extends IO<B>> bodyIO)

Method parameters in com.jnape.palatable.lambda.functions.builtin.fn3 with type arguments of type IO

Modifier and Type	Method	Description
static <A,B> Fn1<Fn1<? super A, ? extends IO<B>>, IO<B>>	Bracket.bracket(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO)
static <A,B> IO<B>	Bracket.bracket(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO, Fn1<? super A, ? extends IO<B>> bodyIO)
IO<B>	Bracket.checkedApply(IO<A> io, Fn1<? super A, ? extends IO<?>> cleanupIO, Fn1<? super A, ? extends IO<B>> bodyIO)

Uses of IO in com.jnape.palatable.lambda.io

Subclasses of IO in com.jnape.palatable.lambda.io

Modifier and Type	Class	Description
private static final class	IO.Compose<A>

Classes in com.jnape.palatable.lambda.io that implement interfaces with type arguments of type IO

Modifier and Type	Class	Description
class	IO<A>	A Monad representing some side-effecting computation to be performed.
class	IO<A>	A Monad representing some side-effecting computation to be performed.

Fields in com.jnape.palatable.lambda.io declared as IO

Modifier and Type	Field	Description
private final IO<?>	IO.Compose.source

Fields in com.jnape.palatable.lambda.io with type parameters of type IO

Modifier and Type	Field	Description
private final Choice2<IO<?>, Fn1<Object,IO<?>>>	IO.Compose.composition
private final Choice2<IO<?>, Fn1<Object,IO<?>>>	IO.Compose.composition

Methods in com.jnape.palatable.lambda.io that return IO

Modifier and Type	Method	Description
final IO<A>	IO.catchError(Fn1<? super Throwable, ? extends Monad<A,IO<?>>> recoveryFn)	Catch any thrown errors inside the Monad and resume normal operations.
final <B> IO<B>	IO.discardL(Applicative<B,IO<?>> appB)	Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
final <B> IO<A>	IO.discardR(Applicative<B,IO<?>> appB)	Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
final IO<A>	IO.ensuring(IO<?> ensureIO)	Return an IO that will run ensureIO strictly after running this IO regardless of whether this IO terminates normally, analogous to a finally block.
final IO<A>	IO.exceptionally(Fn1<? super Throwable, ? extends A> recoveryFn)	Deprecated. in favor of canonical IO.catchError(Fn1)
static <A> IO<A>	IO.externallyManaged(Fn0<CompletableFuture<A>> supplier)	Static factory method for creating an IO from an externally managed source of completable futures.
final <B> IO<B>	IO.flatMap(Fn1<? super A, ? extends Monad<B,IO<?>>> f)	Chain dependent computations that may continue or short-circuit based on previous results.
final <B> IO<B>	IO.fmap(Fn1<? super A, ? extends B> fn)	Covariantly transmute this functor's parameter using the given mapping function.
static <A> IO<A>	IO.fuse(IO<A> io)	Fuse all fork opportunities of a given IO such that, unless it is pinned (or is originally externally managed), no parallelism will be used when running it, regardless of what semantics are used when it is executed.
static <A> IO<A>	IO.interruptible(IO<A> io)	Wrap the given IO in an IO that first checks if the thread the IO runs on is interrupted.
static <A> IO<A>	IO.io(A a)	Static factory method for creating an IO that just returns a when performed.
static <A> IO<A>	IO.io(Fn0<? extends A> fn0)	Static factory method for coercing a lambda to an IO.
static IO<Unit>	IO.io(SideEffect sideEffect)	Static factory method for creating an IO that runs a SideEffect and returns Unit.
static <A> IO<A>	IO.memoize(IO<A> io)	Given an IO, return an IO that wraps it, caches its first successful result, and guarantees that no subsequent interactions will happen with it afterwards, returning the cached result thereafter.
static <A> IO<A>	IO.monitorSync(Object lock, IO<A> io)	Synchronize the given IO using the provided lock object.
static <A> IO<A>	IO.pin(IO<A> io, Executor executor)	Pin an IO to an Executor such that regardless of what future decisions are made, when it runs, it will run using whatever parallelism is supported by the Executor's threading model.
final <B> IO<B>	IO.pure(B b)	Lift the value b into this applicative functor.
final IO<Either<Throwable, A>>	IO.safe()	Return a safe IO that will never throw by lifting the result of this IO into Either, catching any Throwable and wrapping it in a left.
final IO<A>	IO.throwError(Throwable throwable)	Throw an error value of type E into the monad.
static <A> IO<A>	IO.throwing(Throwable t)	Produce an IO that throws the given Throwable when executed.
<B> IO<B>	IO.trampolineM(Fn1<? super A, ? extends MonadRec<RecursiveResult<A,B>, IO<?>>> fn)	Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.
final <B> IO<B>	IO.zip(Applicative<Fn1<? super A, ? extends B>, IO<?>> appFn)	Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.

Methods in com.jnape.palatable.lambda.io that return types with arguments of type IO

Modifier and Type	Method	Description
final <B> Lazy<IO<B>>	IO.lazyZip(Lazy<? extends Applicative<Fn1<? super A, ? extends B>, IO<?>>> lazyAppFn)	Given a lazy instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
static Pure<IO<?>>	IO.pureIO()	The canonical Pure instance for IO.

Methods in com.jnape.palatable.lambda.io with parameters of type IO

Modifier and Type	Method	Description
final IO<A>	IO.ensuring(IO<?> ensureIO)	Return an IO that will run ensureIO strictly after running this IO regardless of whether this IO terminates normally, analogous to a finally block.
static <A> IO<A>	IO.fuse(IO<A> io)	Fuse all fork opportunities of a given IO such that, unless it is pinned (or is originally externally managed), no parallelism will be used when running it, regardless of what semantics are used when it is executed.
static <A> IO<A>	IO.interruptible(IO<A> io)	Wrap the given IO in an IO that first checks if the thread the IO runs on is interrupted.
static <A> IO<A>	IO.memoize(IO<A> io)	Given an IO, return an IO that wraps it, caches its first successful result, and guarantees that no subsequent interactions will happen with it afterwards, returning the cached result thereafter.
static <A> IO<A>	IO.monitorSync(Object lock, IO<A> io)	Synchronize the given IO using the provided lock object.
static <A> IO<A>	IO.pin(IO<A> io, Executor executor)	Pin an IO to an Executor such that regardless of what future decisions are made, when it runs, it will run using whatever parallelism is supported by the Executor's threading model.

Method parameters in com.jnape.palatable.lambda.io with type arguments of type IO

Modifier and Type	Method	Description
final IO<A>	IO.catchError(Fn1<? super Throwable, ? extends Monad<A,IO<?>>> recoveryFn)	Catch any thrown errors inside the Monad and resume normal operations.
final <B> IO<B>	IO.discardL(Applicative<B,IO<?>> appB)	Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
final <B> IO<A>	IO.discardR(Applicative<B,IO<?>> appB)	Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
final <B> IO<B>	IO.flatMap(Fn1<? super A, ? extends Monad<B,IO<?>>> f)	Chain dependent computations that may continue or short-circuit based on previous results.
final <B> Lazy<IO<B>>	IO.lazyZip(Lazy<? extends Applicative<Fn1<? super A, ? extends B>, IO<?>>> lazyAppFn)	Given a lazy instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
<B> IO<B>	IO.trampolineM(Fn1<? super A, ? extends MonadRec<RecursiveResult<A,B>, IO<?>>> fn)	Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.
final <B> IO<B>	IO.zip(Applicative<Fn1<? super A, ? extends B>, IO<?>> appFn)	Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.

Constructors in com.jnape.palatable.lambda.io with parameters of type IO

Modifier	Constructor	Description
private	Compose(IO<?> source, Choice2<IO<?>, Fn1<Object,IO<?>>> composition)

Constructor parameters in com.jnape.palatable.lambda.io with type arguments of type IO

Modifier	Constructor	Description
private	Compose(IO<?> source, Choice2<IO<?>, Fn1<Object,IO<?>>> composition)
private	Compose(IO<?> source, Choice2<IO<?>, Fn1<Object,IO<?>>> composition)

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

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

Modifier and Type	Method	Description
static <A> IterateT<IO<?>,A>	IterateT.fromIterator(Iterator<A> as)	Lazily unfold an IterateT from an Iterator inside IO.

Uses of IO in com.jnape.palatable.lambda.monoid.builtin

Classes in com.jnape.palatable.lambda.monoid.builtin that implement interfaces with type arguments of type IO

Modifier and Type	Class	Description
final class	RunAll<A>	Run IO operations, aggregating their results in terms of the provided Monoid.

Methods in com.jnape.palatable.lambda.monoid.builtin that return IO

Modifier and Type	Method	Description
static <A> IO<A>	RunAll.runAll(Monoid<A> monoid, IO<A> x, IO<A> y)

Methods in com.jnape.palatable.lambda.monoid.builtin that return types with arguments of type IO

Modifier and Type	Method	Description
Monoid<IO<A>>	RunAll.checkedApply(Monoid<A> monoid)
static <A> Monoid<IO<A>>	RunAll.runAll(Monoid<A> monoid)
static <A> Fn1<IO<A>,IO<A>>	RunAll.runAll(Monoid<A> monoid, IO<A> x)
static <A> Fn1<IO<A>,IO<A>>	RunAll.runAll(Monoid<A> monoid, IO<A> x)

Methods in com.jnape.palatable.lambda.monoid.builtin with parameters of type IO

Modifier and Type	Method	Description
static <A> Fn1<IO<A>,IO<A>>	RunAll.runAll(Monoid<A> monoid, IO<A> x)
static <A> IO<A>	RunAll.runAll(Monoid<A> monoid, IO<A> x, IO<A> y)

Uses of IO in com.jnape.palatable.lambda.semigroup.builtin

Classes in com.jnape.palatable.lambda.semigroup.builtin that implement interfaces with type arguments of type IO

Modifier and Type	Class	Description
final class	RunAll<A>	Run IO operations, aggregating their results in terms of the provided Semigroup.

Methods in com.jnape.palatable.lambda.semigroup.builtin that return IO

Modifier and Type	Method	Description
static <A> IO<A>	RunAll.runAll(Semigroup<A> semigroup, IO<A> ioX, IO<A> ioY)

Methods in com.jnape.palatable.lambda.semigroup.builtin that return types with arguments of type IO

Modifier and Type	Method	Description
Semigroup<IO<A>>	RunAll.checkedApply(Semigroup<A> semigroup)
static <A> Semigroup<IO<A>>	RunAll.runAll(Semigroup<A> semigroup)
static <A> Fn1<IO<A>,IO<A>>	RunAll.runAll(Semigroup<A> semigroup, IO<A> ioX)
static <A> Fn1<IO<A>,IO<A>>	RunAll.runAll(Semigroup<A> semigroup, IO<A> ioX)

Methods in com.jnape.palatable.lambda.semigroup.builtin with parameters of type IO

Modifier and Type	Method	Description
static <A> Fn1<IO<A>,IO<A>>	RunAll.runAll(Semigroup<A> semigroup, IO<A> ioX)
static <A> IO<A>	RunAll.runAll(Semigroup<A> semigroup, IO<A> ioX, IO<A> ioY)