## 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.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 and Description
    --- | ---
    `Maybe<A>` | Maybe.`peek(Fn1<? super A,? extends IO<?>> effect)` Deprecated. in favor of `matching` into an `IO` and explicitly running it
    `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 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

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

    Methods in com.jnape.palatable.lambda.functions that return IO
    Modifier and Type | Method and 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 and 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

    Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return IO
    Modifier and Type | Method and 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>` | Until.`checkedApply(Fn1<? super A,? extends Boolean> pred, IO<A> io)`
    `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)`
    `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 and 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 and 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<A>` | Until.`checkedApply(Fn1<? super A,? extends Boolean> pred, IO<A> io)`
    `IO<B>` | AutoBracket.`checkedApply(IO<A> io, Fn1<? super A,? extends IO<B>> bodyIO)`
    `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 and 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)`
    `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.
    `FAB` | Peek2.`checkedApply(Fn1<? super A,? extends IO<?>> effectA, Fn1<? super B,? extends IO<?>> effectB, FAB fab)` Deprecated.
    `IO<B>` | AutoBracket.`checkedApply(IO<A> io, Fn1<? super A,? extends IO<B>> bodyIO)`
    `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,?>> 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.
    `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

    Methods in com.jnape.palatable.lambda.functions.builtin.fn3 that return IO
    Modifier and Type | Method and 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 and 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 and 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 and 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)`
    `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)`
    `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

    Methods in com.jnape.palatable.lambda.io that return IO
    Modifier and Type | Method and Description
    --- | ---
    `IO<A>` | IO.`catchError(Fn1<? super Throwable,? extends Monad<A,IO<?>>> recoveryFn)` Catch any `thrown` errors inside the `Monad` and resume normal operations.
    `<B> IO<B>` | IO.`discardL(Applicative<B,IO<?>> appB)` Sequence both this `Applicative` and `appB`, discarding this `Applicative's` result and returning `appB`.
    `<B> IO<A>` | IO.`discardR(Applicative<B,IO<?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `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.
    `IO<A>` | IO.`exceptionally(Fn1<? super Throwable,? extends A> recoveryFn)` Deprecated. in favor of canonical `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`.
    `<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.
    `<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.
    `<B> IO<B>` | IO.`pure(B b)` Lift the value `b` into this applicative functor.
    `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`.
    `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.
    `<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 and Description
    --- | ---
    `<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 and Description
    --- | ---
    `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 and Description
    --- | ---
    `IO<A>` | IO.`catchError(Fn1<? super Throwable,? extends Monad<A,IO<?>>> recoveryFn)` Catch any `thrown` errors inside the `Monad` and resume normal operations.
    `<B> IO<B>` | IO.`discardL(Applicative<B,IO<?>> appB)` Sequence both this `Applicative` and `appB`, discarding this `Applicative's` result and returning `appB`.
    `<B> IO<A>` | IO.`discardR(Applicative<B,IO<?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `<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.
    `<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.
    `<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.

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

    Methods in com.jnape.palatable.lambda.monoid.builtin that return IO
    Modifier and Type | Method and 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 and 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 and 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)`
    `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

    Methods in com.jnape.palatable.lambda.semigroup.builtin that return IO
    Modifier and Type | Method and 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 and 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 and 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)`
    `static <A> IO<A>` | RunAll.`runAll(Semigroup<A> semigroup, IO<A> ioX, IO<A> ioY)`