## Uses of Interface
com.jnape.palatable.lambda.functions.Fn1

- Packages that use Fn1
  Package | Description
  --- | ---
  com.jnape.palatable.lambda.adt |
  com.jnape.palatable.lambda.adt.choice |
  com.jnape.palatable.lambda.adt.coproduct |
  com.jnape.palatable.lambda.adt.hlist |
  com.jnape.palatable.lambda.functions |
  com.jnape.palatable.lambda.functions.builtin.fn1 |
  com.jnape.palatable.lambda.functions.builtin.fn2 |
  com.jnape.palatable.lambda.functions.builtin.fn3 |
  com.jnape.palatable.lambda.functions.builtin.fn4 |
  com.jnape.palatable.lambda.functions.builtin.fn5 |
  com.jnape.palatable.lambda.functions.builtin.fn6 |
  com.jnape.palatable.lambda.functions.builtin.fn7 |
  com.jnape.palatable.lambda.functions.builtin.fn8 |
  com.jnape.palatable.lambda.functions.recursion |
  com.jnape.palatable.lambda.functions.specialized |
  com.jnape.palatable.lambda.functor |
  com.jnape.palatable.lambda.functor.builtin |
  com.jnape.palatable.lambda.internal.iteration |
  com.jnape.palatable.lambda.io |
  com.jnape.palatable.lambda.monad |
  com.jnape.palatable.lambda.monad.transformer |
  com.jnape.palatable.lambda.monad.transformer.builtin |
  com.jnape.palatable.lambda.monoid |
  com.jnape.palatable.lambda.monoid.builtin |
  com.jnape.palatable.lambda.optics |
  com.jnape.palatable.lambda.optics.functions |
  com.jnape.palatable.lambda.optics.lenses |
  com.jnape.palatable.lambda.optics.prisms |
  com.jnape.palatable.lambda.semigroup |
  com.jnape.palatable.lambda.semigroup.builtin |
  com.jnape.palatable.lambda.traversable |

- - ### Uses of Fn1 in com.jnape.palatable.lambda.adt

    Methods in com.jnape.palatable.lambda.adt with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<C,D> These<C,D>` | These.`biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually map covariantly over both the left and right parameters.
    `<C,D> These<C,D>` | These.`biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually map covariantly over both the left and right parameters.
    `<L2,R2> Either<L2,R2>` | Either.`biMap(Fn1<? super L,? extends L2> leftFn, Fn1<? super R,? extends R2> rightFn)` Dually map covariantly over both the left and right parameters.
    `<L2,R2> Either<L2,R2>` | Either.`biMap(Fn1<? super L,? extends L2> leftFn, Fn1<? super R,? extends R2> rightFn)` Dually map covariantly over both the left and right parameters.
    `<Z> These<Z,B>` | These.`biMapL(Fn1<? super A,? extends Z> fn)` Covariantly map over the left parameter.
    `<L2> Either<L2,R>` | Either.`biMapL(Fn1<? super L,? extends L2> fn)` Covariantly map over the left parameter.
    `<C> These<A,C>` | These.`biMapR(Fn1<? super B,? extends C> fn)` Covariantly map over the right parameter.
    `<R2> Either<L,R2>` | Either.`biMapR(Fn1<? super R,? extends R2> fn)` Covariantly map over the right parameter.
    `Either<L,R>` | Either.`catchError(Fn1<? super L,? extends Monad<R,Either<L,?>>> recoveryFn)` Catch any `thrown` errors inside the `Monad` and resume normal operations.
    `Try<A>` | Try.`catchError(Fn1<? super Throwable,? extends Monad<A,Try<?>>> recoveryFn)` Catch any `thrown` errors inside the `Monad` and resume normal operations.
    `Maybe<A>` | Maybe.`catchError(Fn1<? super Unit,? extends Monad<A,Maybe<?>>> recoveryFn)` Catch any `thrown` errors inside the `Monad` and resume normal operations.
    `<S extends Throwable> Try<A>` | Try.`catching(Class<S> throwableType, Fn1<? super S,? extends A> recoveryFn)` Catch any instance of `throwableType` and map it to a success value.
    `Try<A>` | Try.`catching(Fn1<? super Throwable,? extends Boolean> predicate, Fn1<? super Throwable,? extends A> recoveryFn)` Catch any thrown `T` satisfying `predicate` and map it to a success value.
    `Try<A>` | Try.`catching(Fn1<? super Throwable,? extends Boolean> predicate, Fn1<? super Throwable,? extends A> recoveryFn)` Catch any thrown `T` satisfying `predicate` and map it to a success value.
    `Maybe<A>` | Maybe.`filter(Fn1<? super A,? extends Boolean> predicate)` If this value is present and satisfies `predicate`, return `just` the value; otherwise, return `nothing`.
    `Either<L,R>` | Either.`filter(Fn1<? super R,? extends Boolean> pred, Fn0<L> leftFn0)` If this is a right value, apply `pred` to it.
    `Either<L,R>` | Either.`filter(Fn1<? super R,? extends Boolean> pred, Fn1<? super R,? extends L> leftFn)` If this is a right value, apply `pred` to it.
    `Either<L,R>` | Either.`filter(Fn1<? super R,? extends Boolean> pred, Fn1<? super R,? extends L> leftFn)` If this is a right value, apply `pred` to it.
    `<B> Maybe<B>` | Maybe.`flatMap(Fn1<? super A,? extends Monad<B,Maybe<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> Try<B>` | Try.`flatMap(Fn1<? super A,? extends Monad<B,Try<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<C> These<A,C>` | These.`flatMap(Fn1<? super B,? extends Monad<C,These<A,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<R2> Either<L,R2>` | Either.`flatMap(Fn1<? super R,? extends Monad<R2,Either<L,?>>> rightFn)` If a right value, unwrap it and apply it to `rightFn`, returning the resulting `Either<L ,R>`.
    `<B> Maybe<B>` | Maybe.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> Try<B>` | Try.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<C> These<A,C>` | These.`fmap(Fn1<? super B,? extends C> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<R2> Either<L,R2>` | Either.`fmap(Fn1<? super R,? extends R2> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `Throwable` | Try.`forfeit(Fn1<? super A,? extends Throwable> fn)` If this is a failure, return the wrapped value.
    `L` | Either.`forfeit(Fn1<? super R,? extends L> forfeitFn)` Inverse of recover.
    `abstract <V> V` | Either.`match(Fn1<? super L,? extends V> leftFn, Fn1<? super R,? extends V> rightFn)` Given two mapping functions (one from an `L` to a `V`, one from an `R` to a `V`), unwrap the value stored in this `Either`, apply the appropriate mapping function, and return the result.
    `abstract <V> V` | Either.`match(Fn1<? super L,? extends V> leftFn, Fn1<? super R,? extends V> rightFn)` Given two mapping functions (one from an `L` to a `V`, one from an `R` to a `V`), unwrap the value stored in this `Either`, apply the appropriate mapping function, and return the result.
    `<T extends Throwable> R` | Either.`orThrow(Fn1<? super L,? extends T> throwableFn)` Return the wrapped value if this is a right; otherwise, map the wrapped left value to a `T` and throw it.
    `abstract <T extends Throwable> A` | Try.`orThrow(Fn1<? super Throwable,? extends T> fn)` If this is a success value, return it.
    `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
    `R` | Either.`recover(Fn1<? super L,? extends R> recoveryFn)` "Recover" from a left value by applying a recoveryFn to the wrapped value and returning it in the case of a left value; otherwise, return the wrapped right value.
    `A` | Try.`recover(Fn1<? super Throwable,? extends A> fn)` If this is a success, return the wrapped value.
    `<L> Either<L,A>` | Try.`toEither(Fn1<? super Throwable,? extends L> fn)` If this is a success, wrap the value in a `Either.right(R)` and return it.
    `<B> Maybe<B>` | Maybe.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Maybe<?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> Try<B>` | Try.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Try<?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<C> These<A,C>` | These.`trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,These<A,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> Either<L,B>` | Either.`trampolineM(Fn1<? super R,? extends MonadRec<RecursiveResult<R,B>,Either<L,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,Maybe<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Maybe.`traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)`
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,Maybe<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Maybe.`traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)`
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,Try<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Try.`traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,Try<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Try.`traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<C,App extends Applicative<?,App>,TravC extends Traversable<C,These<A,?>>,AppTrav extends Applicative<TravC,App>> AppTrav` | These.`traverse(Fn1<? super B,? extends Applicative<C,App>> fn, Fn1<? super TravC,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<C,App extends Applicative<?,App>,TravC extends Traversable<C,These<A,?>>,AppTrav extends Applicative<TravC,App>> AppTrav` | These.`traverse(Fn1<? super B,? extends Applicative<C,App>> fn, Fn1<? super TravC,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<R2,App extends Applicative<?,App>,TravB extends Traversable<R2,Either<L,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Either.`traverse(Fn1<? super R,? extends Applicative<R2,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<R2,App extends Applicative<?,App>,TravB extends Traversable<R2,Either<L,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Either.`traverse(Fn1<? super R,? extends Applicative<R2,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `static <L,R> Either<L,R>` | Either.`trying(Fn0<? extends R> fn0, Fn1<? super Throwable,? extends L> leftFn)` Attempt to execute the `Fn0`, returning its result in a right value.
    `static <L> Either<L,Unit>` | Either.`trying(SideEffect sideEffect, Fn1<? super Throwable,? extends L> leftFn)` Attempt to execute the `SideEffect`, returning `Unit` in a right value.
    `static <A extends AutoCloseable,B extends AutoCloseable,C extends AutoCloseable,D> Try<D>` | Try.`withResources(Fn0<? extends A> fn0, Fn1<? super A,? extends B> bFn, Fn1<? super B,? extends C> cFn, Fn1<? super C,? extends Try<? extends D>> fn)` Convenience overload of `withResources` that cascades two dependent resource creations via nested calls.
    `static <A extends AutoCloseable,B extends AutoCloseable,C extends AutoCloseable,D> Try<D>` | Try.`withResources(Fn0<? extends A> fn0, Fn1<? super A,? extends B> bFn, Fn1<? super B,? extends C> cFn, Fn1<? super C,? extends Try<? extends D>> fn)` Convenience overload of `withResources` that cascades two dependent resource creations via nested calls.
    `static <A extends AutoCloseable,B extends AutoCloseable,C extends AutoCloseable,D> Try<D>` | Try.`withResources(Fn0<? extends A> fn0, Fn1<? super A,? extends B> bFn, Fn1<? super B,? extends C> cFn, Fn1<? super C,? extends Try<? extends D>> fn)` Convenience overload of `withResources` that cascades two dependent resource creations via nested calls.
    `static <A extends AutoCloseable,B extends AutoCloseable,C> Try<C>` | Try.`withResources(Fn0<? extends A> fn0, Fn1<? super A,? extends B> bFn, Fn1<? super B,? extends Try<? extends C>> fn)` Convenience overload of `withResources` that cascades dependent resource creation via nested calls.
    `static <A extends AutoCloseable,B extends AutoCloseable,C> Try<C>` | Try.`withResources(Fn0<? extends A> fn0, Fn1<? super A,? extends B> bFn, Fn1<? super B,? extends Try<? extends C>> fn)` Convenience overload of `withResources` that cascades dependent resource creation via nested calls.
    `static <A extends AutoCloseable,B> Try<B>` | Try.`withResources(Fn0<? extends A> fn0, Fn1<? super A,? extends Try<? extends B>> fn)` Given a ``Fn0`<`AutoCloseable`>` `aSupplier` and an `Fn1` `fn`, apply `fn` to the result of `aSupplier`, ensuring that the result has its `close` method invoked, regardless of the outcome.

    Method parameters in com.jnape.palatable.lambda.adt with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<Maybe<B>>` | Maybe.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Maybe<?>>> lazyAppFn)` Terminate early if this is a `Nothing`; otherwise, continue the `zip`.
    `<B> Lazy<Try<B>>` | Try.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Try<?>>> 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.
    `<C> Lazy<These<A,C>>` | These.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,These<A,?>>> 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.
    `<R2> Lazy<Either<L,R2>>` | Either.`lazyZip(Lazy<? extends Applicative<Fn1<? super R,? extends R2>,Either<L,?>>> 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> Maybe<B>` | Maybe.`zip(Applicative<Fn1<? super A,? extends B>,Maybe<?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<B> Try<B>` | Try.`zip(Applicative<Fn1<? super A,? extends B>,Try<?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<C> These<A,C>` | These.`zip(Applicative<Fn1<? super B,? extends C>,These<A,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<R2> Either<L,R2>` | Either.`zip(Applicative<Fn1<? super R,? extends R2>,Either<L,?>> 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 Fn1 in com.jnape.palatable.lambda.adt.choice

    Methods in com.jnape.palatable.lambda.adt.choice with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<C,D> Choice2<C,D>` | Choice2.`biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually map covariantly over both the left and right parameters.
    `<C,D> Choice2<C,D>` | Choice2.`biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually map covariantly over both the left and right parameters.
    `<D,E> Choice3<A,D,E>` | Choice3.`biMap(Fn1<? super B,? extends D> lFn, Fn1<? super C,? extends E> rFn)` Dually map covariantly over both the left and right parameters.
    `<D,E> Choice3<A,D,E>` | Choice3.`biMap(Fn1<? super B,? extends D> lFn, Fn1<? super C,? extends E> rFn)` Dually map covariantly over both the left and right parameters.
    `<E,F> Choice4<A,B,E,F>` | Choice4.`biMap(Fn1<? super C,? extends E> lFn, Fn1<? super D,? extends F> rFn)`
    `<E,F> Choice4<A,B,E,F>` | Choice4.`biMap(Fn1<? super C,? extends E> lFn, Fn1<? super D,? extends F> rFn)`
    `<F,G> Choice5<A,B,C,F,G>` | Choice5.`biMap(Fn1<? super D,? extends F> lFn, Fn1<? super E,? extends G> rFn)` Dually map covariantly over both the left and right parameters.
    `<F,G> Choice5<A,B,C,F,G>` | Choice5.`biMap(Fn1<? super D,? extends F> lFn, Fn1<? super E,? extends G> rFn)` Dually map covariantly over both the left and right parameters.
    `<G,H> Choice6<A,B,C,D,G,H>` | Choice6.`biMap(Fn1<? super E,? extends G> lFn, Fn1<? super F,? extends H> rFn)` Dually map covariantly over both the left and right parameters.
    `<G,H> Choice6<A,B,C,D,G,H>` | Choice6.`biMap(Fn1<? super E,? extends G> lFn, Fn1<? super F,? extends H> rFn)` Dually map covariantly over both the left and right parameters.
    `<H,I> Choice7<A,B,C,D,E,H,I>` | Choice7.`biMap(Fn1<? super F,? extends H> lFn, Fn1<? super G,? extends I> rFn)` Dually map covariantly over both the left and right parameters.
    `<H,I> Choice7<A,B,C,D,E,H,I>` | Choice7.`biMap(Fn1<? super F,? extends H> lFn, Fn1<? super G,? extends I> rFn)` Dually map covariantly over both the left and right parameters.
    `<I,J> Choice8<A,B,C,D,E,F,I,J>` | Choice8.`biMap(Fn1<? super G,? extends I> lFn, Fn1<? super H,? extends J> rFn)` Dually map covariantly over both the left and right parameters.
    `<I,J> Choice8<A,B,C,D,E,F,I,J>` | Choice8.`biMap(Fn1<? super G,? extends I> lFn, Fn1<? super H,? extends J> rFn)` Dually map covariantly over both the left and right parameters.
    `<C> Choice2<C,B>` | Choice2.`biMapL(Fn1<? super A,? extends C> fn)` Covariantly map over the left parameter.
    `<D> Choice3<A,D,C>` | Choice3.`biMapL(Fn1<? super B,? extends D> fn)` Covariantly map over the left parameter.
    `<E> Choice4<A,B,E,D>` | Choice4.`biMapL(Fn1<? super C,? extends E> fn)` Covariantly map over the left parameter.
    `<F> Choice5<A,B,C,F,E>` | Choice5.`biMapL(Fn1<? super D,? extends F> fn)` Covariantly map over the left parameter.
    `<G> Choice6<A,B,C,D,G,F>` | Choice6.`biMapL(Fn1<? super E,? extends G> fn)` Covariantly map over the left parameter.
    `<H> Choice7<A,B,C,D,E,H,G>` | Choice7.`biMapL(Fn1<? super F,? extends H> fn)` Covariantly map over the left parameter.
    `<I> Choice8<A,B,C,D,E,F,I,H>` | Choice8.`biMapL(Fn1<? super G,? extends I> fn)` Covariantly map over the left parameter.
    `<C> Choice2<A,C>` | Choice2.`biMapR(Fn1<? super B,? extends C> fn)` Covariantly map over the right parameter.
    `<D> Choice3<A,B,D>` | Choice3.`biMapR(Fn1<? super C,? extends D> fn)` Covariantly map over the right parameter.
    `<E> Choice4<A,B,C,E>` | Choice4.`biMapR(Fn1<? super D,? extends E> fn)` Covariantly map over the right parameter.
    `<F> Choice5<A,B,C,D,F>` | Choice5.`biMapR(Fn1<? super E,? extends F> fn)` Covariantly map over the right parameter.
    `<G> Choice6<A,B,C,D,E,G>` | Choice6.`biMapR(Fn1<? super F,? extends G> fn)` Covariantly map over the right parameter.
    `<H> Choice7<A,B,C,D,E,F,H>` | Choice7.`biMapR(Fn1<? super G,? extends H> fn)` Covariantly map over the right parameter.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`biMapR(Fn1<? super H,? extends I> fn)` Covariantly map over the right parameter.
    `Choice2<A,B>` | Choice3.`converge(Fn1<? super C,? extends CoProduct2<A,B,?>> convergenceFn)` Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
    `Choice3<A,B,C>` | Choice4.`converge(Fn1<? super D,? extends CoProduct3<A,B,C,?>> convergenceFn)` Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
    `Choice4<A,B,C,D>` | Choice5.`converge(Fn1<? super E,? extends CoProduct4<A,B,C,D,?>> convergenceFn)` Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
    `Choice5<A,B,C,D,E>` | Choice6.`converge(Fn1<? super F,? extends CoProduct5<A,B,C,D,E,?>> convergenceFn)` Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
    `Choice6<A,B,C,D,E,F>` | Choice7.`converge(Fn1<? super G,? extends CoProduct6<A,B,C,D,E,F,?>> convergenceFn)` Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
    `Choice7<A,B,C,D,E,F,G>` | Choice8.`converge(Fn1<? super H,? extends CoProduct7<A,B,C,D,E,F,G,?>> convergenceFn)` Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
    `<C> Choice2<A,C>` | Choice2.`flatMap(Fn1<? super B,? extends Monad<C,Choice2<A,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<D> Choice3<A,B,D>` | Choice3.`flatMap(Fn1<? super C,? extends Monad<D,Choice3<A,B,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<E> Choice4<A,B,C,E>` | Choice4.`flatMap(Fn1<? super D,? extends Monad<E,Choice4<A,B,C,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<F> Choice5<A,B,C,D,F>` | Choice5.`flatMap(Fn1<? super E,? extends Monad<F,Choice5<A,B,C,D,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<G> Choice6<A,B,C,D,E,G>` | Choice6.`flatMap(Fn1<? super F,? extends Monad<G,Choice6<A,B,C,D,E,?>>> fn)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<H> Choice7<A,B,C,D,E,F,H>` | Choice7.`flatMap(Fn1<? super G,? extends Monad<H,Choice7<A,B,C,D,E,F,?>>> fn)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`flatMap(Fn1<? super H,? extends Monad<I,Choice8<A,B,C,D,E,F,G,?>>> fn)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<C> Choice2<A,C>` | Choice2.`fmap(Fn1<? super B,? extends C> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<D> Choice3<A,B,D>` | Choice3.`fmap(Fn1<? super C,? extends D> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<E> Choice4<A,B,C,E>` | Choice4.`fmap(Fn1<? super D,? extends E> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<F> Choice5<A,B,C,D,F>` | Choice5.`fmap(Fn1<? super E,? extends F> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<G> Choice6<A,B,C,D,E,G>` | Choice6.`fmap(Fn1<? super F,? extends G> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<H> Choice7<A,B,C,D,E,F,H>` | Choice7.`fmap(Fn1<? super G,? extends H> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`fmap(Fn1<? super H,? extends I> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<C> Choice2<A,C>` | Choice2.`trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Choice2<A,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<D> Choice3<A,B,D>` | Choice3.`trampolineM(Fn1<? super C,? extends MonadRec<RecursiveResult<C,D>,Choice3<A,B,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<E> Choice4<A,B,C,E>` | Choice4.`trampolineM(Fn1<? super D,? extends MonadRec<RecursiveResult<D,E>,Choice4<A,B,C,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<F> Choice5<A,B,C,D,F>` | Choice5.`trampolineM(Fn1<? super E,? extends MonadRec<RecursiveResult<E,F>,Choice5<A,B,C,D,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<G> Choice6<A,B,C,D,E,G>` | Choice6.`trampolineM(Fn1<? super F,? extends MonadRec<RecursiveResult<F,G>,Choice6<A,B,C,D,E,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<H> Choice7<A,B,C,D,E,F,H>` | Choice7.`trampolineM(Fn1<? super G,? extends MonadRec<RecursiveResult<G,H>,Choice7<A,B,C,D,E,F,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`trampolineM(Fn1<? super H,? extends MonadRec<RecursiveResult<H,I>,Choice8<A,B,C,D,E,F,G,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<C,App extends Applicative<?,App>,TravB extends Traversable<C,Choice2<A,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice2.`traverse(Fn1<? super B,? extends Applicative<C,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<C,App extends Applicative<?,App>,TravB extends Traversable<C,Choice2<A,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice2.`traverse(Fn1<? super B,? extends Applicative<C,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<D,App extends Applicative<?,App>,TravB extends Traversable<D,Choice3<A,B,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice3.`traverse(Fn1<? super C,? extends Applicative<D,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<D,App extends Applicative<?,App>,TravB extends Traversable<D,Choice3<A,B,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice3.`traverse(Fn1<? super C,? extends Applicative<D,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<E,App extends Applicative<?,App>,TravB extends Traversable<E,Choice4<A,B,C,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice4.`traverse(Fn1<? super D,? extends Applicative<E,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<E,App extends Applicative<?,App>,TravB extends Traversable<E,Choice4<A,B,C,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice4.`traverse(Fn1<? super D,? extends Applicative<E,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<F,App extends Applicative<?,App>,TravB extends Traversable<F,Choice5<A,B,C,D,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice5.`traverse(Fn1<? super E,? extends Applicative<F,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<F,App extends Applicative<?,App>,TravB extends Traversable<F,Choice5<A,B,C,D,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice5.`traverse(Fn1<? super E,? extends Applicative<F,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<G,App extends Applicative<?,App>,TravB extends Traversable<G,Choice6<A,B,C,D,E,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice6.`traverse(Fn1<? super F,? extends Applicative<G,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<G,App extends Applicative<?,App>,TravB extends Traversable<G,Choice6<A,B,C,D,E,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice6.`traverse(Fn1<? super F,? extends Applicative<G,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<H,App extends Applicative<?,App>,TravB extends Traversable<H,Choice7<A,B,C,D,E,F,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice7.`traverse(Fn1<? super G,? extends Applicative<H,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<H,App extends Applicative<?,App>,TravB extends Traversable<H,Choice7<A,B,C,D,E,F,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice7.`traverse(Fn1<? super G,? extends Applicative<H,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<I,App extends Applicative<?,App>,TravB extends Traversable<I,Choice8<A,B,C,D,E,F,G,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice8.`traverse(Fn1<? super H,? extends Applicative<I,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<I,App extends Applicative<?,App>,TravB extends Traversable<I,Choice8<A,B,C,D,E,F,G,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Choice8.`traverse(Fn1<? super H,? extends Applicative<I,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.

    Method parameters in com.jnape.palatable.lambda.adt.choice with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<C> Lazy<Choice2<A,C>>` | Choice2.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Choice2<A,?>>> 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.
    `<D> Lazy<Choice3<A,B,D>>` | Choice3.`lazyZip(Lazy<? extends Applicative<Fn1<? super C,? extends D>,Choice3<A,B,?>>> 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.
    `<E> Lazy<Choice4<A,B,C,E>>` | Choice4.`lazyZip(Lazy<? extends Applicative<Fn1<? super D,? extends E>,Choice4<A,B,C,?>>> 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.
    `<F> Lazy<Choice5<A,B,C,D,F>>` | Choice5.`lazyZip(Lazy<? extends Applicative<Fn1<? super E,? extends F>,Choice5<A,B,C,D,?>>> 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.
    `<G> Lazy<Choice6<A,B,C,D,E,G>>` | Choice6.`lazyZip(Lazy<? extends Applicative<Fn1<? super F,? extends G>,Choice6<A,B,C,D,E,?>>> 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.
    `<H> Lazy<Choice7<A,B,C,D,E,F,H>>` | Choice7.`lazyZip(Lazy<? extends Applicative<Fn1<? super G,? extends H>,Choice7<A,B,C,D,E,F,?>>> 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.
    `<I> Lazy<Choice8<A,B,C,D,E,F,G,I>>` | Choice8.`lazyZip(Lazy<? extends Applicative<Fn1<? super H,? extends I>,Choice8<A,B,C,D,E,F,G,?>>> 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.
    `<C> Choice2<A,C>` | Choice2.`zip(Applicative<Fn1<? super B,? extends C>,Choice2<A,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<D> Choice3<A,B,D>` | Choice3.`zip(Applicative<Fn1<? super C,? extends D>,Choice3<A,B,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<E> Choice4<A,B,C,E>` | Choice4.`zip(Applicative<Fn1<? super D,? extends E>,Choice4<A,B,C,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<F> Choice5<A,B,C,D,F>` | Choice5.`zip(Applicative<Fn1<? super E,? extends F>,Choice5<A,B,C,D,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<G> Choice6<A,B,C,D,E,G>` | Choice6.`zip(Applicative<Fn1<? super F,? extends G>,Choice6<A,B,C,D,E,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<H> Choice7<A,B,C,D,E,F,H>` | Choice7.`zip(Applicative<Fn1<? super G,? extends H>,Choice7<A,B,C,D,E,F,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<I> Choice8<A,B,C,D,E,F,G,I>` | Choice8.`zip(Applicative<Fn1<? super H,? extends I>,Choice8<A,B,C,D,E,F,G,?>> 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 Fn1 in com.jnape.palatable.lambda.adt.coproduct

    Methods in com.jnape.palatable.lambda.adt.coproduct with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default CoProduct2<A,B,? extends CoProduct2<A,B,?>>` | CoProduct3.`converge(Fn1<? super C,? extends CoProduct2<A,B,?>> convergenceFn)` Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
    `default CoProduct3<A,B,C,? extends CoProduct3<A,B,C,?>>` | CoProduct4.`converge(Fn1<? super D,? extends CoProduct3<A,B,C,?>> convergenceFn)` Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
    `default CoProduct4<A,B,C,D,? extends CoProduct4<A,B,C,D,?>>` | CoProduct5.`converge(Fn1<? super E,? extends CoProduct4<A,B,C,D,?>> convergenceFn)` Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
    `default CoProduct5<A,B,C,D,E,? extends CoProduct5<A,B,C,D,E,?>>` | CoProduct6.`converge(Fn1<? super F,? extends CoProduct5<A,B,C,D,E,?>> convergenceFn)` Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
    `default CoProduct6<A,B,C,D,E,F,? extends CoProduct6<A,B,C,D,E,F,?>>` | CoProduct7.`converge(Fn1<? super G,? extends CoProduct6<A,B,C,D,E,F,?>> convergenceFn)` Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
    `default CoProduct7<A,B,C,D,E,F,G,? extends CoProduct7<A,B,C,D,E,F,G,?>>` | CoProduct8.`converge(Fn1<? super H,? extends CoProduct7<A,B,C,D,E,F,G,?>> convergenceFn)` Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
    `default <R> R` | CoProduct2.`embed(Fn1<? super CP2,? extends R> aFn, Fn1<? super CP2,? extends R> bFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct2.`embed(Fn1<? super CP2,? extends R> aFn, Fn1<? super CP2,? extends R> bFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct3.`embed(Fn1<? super CP3,? extends R> aFn, Fn1<? super CP3,? extends R> bFn, Fn1<? super CP3,? extends R> cFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct3.`embed(Fn1<? super CP3,? extends R> aFn, Fn1<? super CP3,? extends R> bFn, Fn1<? super CP3,? extends R> cFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct3.`embed(Fn1<? super CP3,? extends R> aFn, Fn1<? super CP3,? extends R> bFn, Fn1<? super CP3,? extends R> cFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct4.`embed(Fn1<? super CP4,? extends R> aFn, Fn1<? super CP4,? extends R> bFn, Fn1<? super CP4,? extends R> cFn, Fn1<? super CP4,? extends R> dFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct4.`embed(Fn1<? super CP4,? extends R> aFn, Fn1<? super CP4,? extends R> bFn, Fn1<? super CP4,? extends R> cFn, Fn1<? super CP4,? extends R> dFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct4.`embed(Fn1<? super CP4,? extends R> aFn, Fn1<? super CP4,? extends R> bFn, Fn1<? super CP4,? extends R> cFn, Fn1<? super CP4,? extends R> dFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct4.`embed(Fn1<? super CP4,? extends R> aFn, Fn1<? super CP4,? extends R> bFn, Fn1<? super CP4,? extends R> cFn, Fn1<? super CP4,? extends R> dFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct5.`embed(Fn1<? super CP5,? extends R> aFn, Fn1<? super CP5,? extends R> bFn, Fn1<? super CP5,? extends R> cFn, Fn1<? super CP5,? extends R> dFn, Fn1<? super CP5,? extends R> eFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct5.`embed(Fn1<? super CP5,? extends R> aFn, Fn1<? super CP5,? extends R> bFn, Fn1<? super CP5,? extends R> cFn, Fn1<? super CP5,? extends R> dFn, Fn1<? super CP5,? extends R> eFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct5.`embed(Fn1<? super CP5,? extends R> aFn, Fn1<? super CP5,? extends R> bFn, Fn1<? super CP5,? extends R> cFn, Fn1<? super CP5,? extends R> dFn, Fn1<? super CP5,? extends R> eFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct5.`embed(Fn1<? super CP5,? extends R> aFn, Fn1<? super CP5,? extends R> bFn, Fn1<? super CP5,? extends R> cFn, Fn1<? super CP5,? extends R> dFn, Fn1<? super CP5,? extends R> eFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct5.`embed(Fn1<? super CP5,? extends R> aFn, Fn1<? super CP5,? extends R> bFn, Fn1<? super CP5,? extends R> cFn, Fn1<? super CP5,? extends R> dFn, Fn1<? super CP5,? extends R> eFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct6.`embed(Fn1<? super CP6,? extends R> aFn, Fn1<? super CP6,? extends R> bFn, Fn1<? super CP6,? extends R> cFn, Fn1<? super CP6,? extends R> dFn, Fn1<? super CP6,? extends R> eFn, Fn1<? super CP6,? extends R> fFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct6.`embed(Fn1<? super CP6,? extends R> aFn, Fn1<? super CP6,? extends R> bFn, Fn1<? super CP6,? extends R> cFn, Fn1<? super CP6,? extends R> dFn, Fn1<? super CP6,? extends R> eFn, Fn1<? super CP6,? extends R> fFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct6.`embed(Fn1<? super CP6,? extends R> aFn, Fn1<? super CP6,? extends R> bFn, Fn1<? super CP6,? extends R> cFn, Fn1<? super CP6,? extends R> dFn, Fn1<? super CP6,? extends R> eFn, Fn1<? super CP6,? extends R> fFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct6.`embed(Fn1<? super CP6,? extends R> aFn, Fn1<? super CP6,? extends R> bFn, Fn1<? super CP6,? extends R> cFn, Fn1<? super CP6,? extends R> dFn, Fn1<? super CP6,? extends R> eFn, Fn1<? super CP6,? extends R> fFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct6.`embed(Fn1<? super CP6,? extends R> aFn, Fn1<? super CP6,? extends R> bFn, Fn1<? super CP6,? extends R> cFn, Fn1<? super CP6,? extends R> dFn, Fn1<? super CP6,? extends R> eFn, Fn1<? super CP6,? extends R> fFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct6.`embed(Fn1<? super CP6,? extends R> aFn, Fn1<? super CP6,? extends R> bFn, Fn1<? super CP6,? extends R> cFn, Fn1<? super CP6,? extends R> dFn, Fn1<? super CP6,? extends R> eFn, Fn1<? super CP6,? extends R> fFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct7.`embed(Fn1<? super CP7,? extends R> aFn, Fn1<? super CP7,? extends R> bFn, Fn1<? super CP7,? extends R> cFn, Fn1<? super CP7,? extends R> dFn, Fn1<? super CP7,? extends R> eFn, Fn1<? super CP7,? extends R> fFn, Fn1<? super CP7,? extends R> gFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct7.`embed(Fn1<? super CP7,? extends R> aFn, Fn1<? super CP7,? extends R> bFn, Fn1<? super CP7,? extends R> cFn, Fn1<? super CP7,? extends R> dFn, Fn1<? super CP7,? extends R> eFn, Fn1<? super CP7,? extends R> fFn, Fn1<? super CP7,? extends R> gFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct7.`embed(Fn1<? super CP7,? extends R> aFn, Fn1<? super CP7,? extends R> bFn, Fn1<? super CP7,? extends R> cFn, Fn1<? super CP7,? extends R> dFn, Fn1<? super CP7,? extends R> eFn, Fn1<? super CP7,? extends R> fFn, Fn1<? super CP7,? extends R> gFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct7.`embed(Fn1<? super CP7,? extends R> aFn, Fn1<? super CP7,? extends R> bFn, Fn1<? super CP7,? extends R> cFn, Fn1<? super CP7,? extends R> dFn, Fn1<? super CP7,? extends R> eFn, Fn1<? super CP7,? extends R> fFn, Fn1<? super CP7,? extends R> gFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct7.`embed(Fn1<? super CP7,? extends R> aFn, Fn1<? super CP7,? extends R> bFn, Fn1<? super CP7,? extends R> cFn, Fn1<? super CP7,? extends R> dFn, Fn1<? super CP7,? extends R> eFn, Fn1<? super CP7,? extends R> fFn, Fn1<? super CP7,? extends R> gFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct7.`embed(Fn1<? super CP7,? extends R> aFn, Fn1<? super CP7,? extends R> bFn, Fn1<? super CP7,? extends R> cFn, Fn1<? super CP7,? extends R> dFn, Fn1<? super CP7,? extends R> eFn, Fn1<? super CP7,? extends R> fFn, Fn1<? super CP7,? extends R> gFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct7.`embed(Fn1<? super CP7,? extends R> aFn, Fn1<? super CP7,? extends R> bFn, Fn1<? super CP7,? extends R> cFn, Fn1<? super CP7,? extends R> dFn, Fn1<? super CP7,? extends R> eFn, Fn1<? super CP7,? extends R> fFn, Fn1<? super CP7,? extends R> gFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct8.`embed(Fn1<? super CP8,? extends R> aFn, Fn1<? super CP8,? extends R> bFn, Fn1<? super CP8,? extends R> cFn, Fn1<? super CP8,? extends R> dFn, Fn1<? super CP8,? extends R> eFn, Fn1<? super CP8,? extends R> fFn, Fn1<? super CP8,? extends R> gFn, Fn1<? super CP8,? extends R> hFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct8.`embed(Fn1<? super CP8,? extends R> aFn, Fn1<? super CP8,? extends R> bFn, Fn1<? super CP8,? extends R> cFn, Fn1<? super CP8,? extends R> dFn, Fn1<? super CP8,? extends R> eFn, Fn1<? super CP8,? extends R> fFn, Fn1<? super CP8,? extends R> gFn, Fn1<? super CP8,? extends R> hFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct8.`embed(Fn1<? super CP8,? extends R> aFn, Fn1<? super CP8,? extends R> bFn, Fn1<? super CP8,? extends R> cFn, Fn1<? super CP8,? extends R> dFn, Fn1<? super CP8,? extends R> eFn, Fn1<? super CP8,? extends R> fFn, Fn1<? super CP8,? extends R> gFn, Fn1<? super CP8,? extends R> hFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct8.`embed(Fn1<? super CP8,? extends R> aFn, Fn1<? super CP8,? extends R> bFn, Fn1<? super CP8,? extends R> cFn, Fn1<? super CP8,? extends R> dFn, Fn1<? super CP8,? extends R> eFn, Fn1<? super CP8,? extends R> fFn, Fn1<? super CP8,? extends R> gFn, Fn1<? super CP8,? extends R> hFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct8.`embed(Fn1<? super CP8,? extends R> aFn, Fn1<? super CP8,? extends R> bFn, Fn1<? super CP8,? extends R> cFn, Fn1<? super CP8,? extends R> dFn, Fn1<? super CP8,? extends R> eFn, Fn1<? super CP8,? extends R> fFn, Fn1<? super CP8,? extends R> gFn, Fn1<? super CP8,? extends R> hFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct8.`embed(Fn1<? super CP8,? extends R> aFn, Fn1<? super CP8,? extends R> bFn, Fn1<? super CP8,? extends R> cFn, Fn1<? super CP8,? extends R> dFn, Fn1<? super CP8,? extends R> eFn, Fn1<? super CP8,? extends R> fFn, Fn1<? super CP8,? extends R> gFn, Fn1<? super CP8,? extends R> hFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct8.`embed(Fn1<? super CP8,? extends R> aFn, Fn1<? super CP8,? extends R> bFn, Fn1<? super CP8,? extends R> cFn, Fn1<? super CP8,? extends R> dFn, Fn1<? super CP8,? extends R> eFn, Fn1<? super CP8,? extends R> fFn, Fn1<? super CP8,? extends R> gFn, Fn1<? super CP8,? extends R> hFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `default <R> R` | CoProduct8.`embed(Fn1<? super CP8,? extends R> aFn, Fn1<? super CP8,? extends R> bFn, Fn1<? super CP8,? extends R> cFn, Fn1<? super CP8,? extends R> dFn, Fn1<? super CP8,? extends R> eFn, Fn1<? super CP8,? extends R> fFn, Fn1<? super CP8,? extends R> gFn, Fn1<? super CP8,? extends R> hFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `<R> R` | CoProduct2.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct2.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct3.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct3.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct3.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct4.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct4.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct4.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct4.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct5.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct5.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct5.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct5.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct5.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct6.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct6.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct6.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct6.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct6.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct6.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct7.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct7.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct7.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct7.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct7.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct7.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct7.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct8.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn, Fn1<? super H,? extends R> hFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct8.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn, Fn1<? super H,? extends R> hFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct8.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn, Fn1<? super H,? extends R> hFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct8.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn, Fn1<? super H,? extends R> hFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct8.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn, Fn1<? super H,? extends R> hFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct8.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn, Fn1<? super H,? extends R> hFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct8.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn, Fn1<? super H,? extends R> hFn)` Type-safe convergence requiring a match against all potential types.
    `<R> R` | CoProduct8.`match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn, Fn1<? super F,? extends R> fFn, Fn1<? super G,? extends R> gFn, Fn1<? super H,? extends R> hFn)` Type-safe convergence requiring a match against all potential types.

  - ### Uses of Fn1 in com.jnape.palatable.lambda.adt.hlist

    Methods in com.jnape.palatable.lambda.adt.hlist with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<_1Prime,_2Prime> Tuple2<_1Prime,_2Prime>` | Tuple2.`biMap(Fn1<? super _1,? extends _1Prime> lFn, Fn1<? super _2,? extends _2Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_1Prime,_2Prime> Tuple2<_1Prime,_2Prime>` | Tuple2.`biMap(Fn1<? super _1,? extends _1Prime> lFn, Fn1<? super _2,? extends _2Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_2Prime,_3Prime> Tuple3<_1,_2Prime,_3Prime>` | Tuple3.`biMap(Fn1<? super _2,? extends _2Prime> lFn, Fn1<? super _3,? extends _3Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_2Prime,_3Prime> Tuple3<_1,_2Prime,_3Prime>` | Tuple3.`biMap(Fn1<? super _2,? extends _2Prime> lFn, Fn1<? super _3,? extends _3Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_3Prime,_4Prime> Tuple4<_1,_2,_3Prime,_4Prime>` | Tuple4.`biMap(Fn1<? super _3,? extends _3Prime> lFn, Fn1<? super _4,? extends _4Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_3Prime,_4Prime> Tuple4<_1,_2,_3Prime,_4Prime>` | Tuple4.`biMap(Fn1<? super _3,? extends _3Prime> lFn, Fn1<? super _4,? extends _4Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_4Prime,_5Prime> Tuple5<_1,_2,_3,_4Prime,_5Prime>` | Tuple5.`biMap(Fn1<? super _4,? extends _4Prime> lFn, Fn1<? super _5,? extends _5Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_4Prime,_5Prime> Tuple5<_1,_2,_3,_4Prime,_5Prime>` | Tuple5.`biMap(Fn1<? super _4,? extends _4Prime> lFn, Fn1<? super _5,? extends _5Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_5Prime,_6Prime> Tuple6<_1,_2,_3,_4,_5Prime,_6Prime>` | Tuple6.`biMap(Fn1<? super _5,? extends _5Prime> lFn, Fn1<? super _6,? extends _6Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_5Prime,_6Prime> Tuple6<_1,_2,_3,_4,_5Prime,_6Prime>` | Tuple6.`biMap(Fn1<? super _5,? extends _5Prime> lFn, Fn1<? super _6,? extends _6Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_6Prime,_7Prime> Tuple7<_1,_2,_3,_4,_5,_6Prime,_7Prime>` | Tuple7.`biMap(Fn1<? super _6,? extends _6Prime> lFn, Fn1<? super _7,? extends _7Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_6Prime,_7Prime> Tuple7<_1,_2,_3,_4,_5,_6Prime,_7Prime>` | Tuple7.`biMap(Fn1<? super _6,? extends _6Prime> lFn, Fn1<? super _7,? extends _7Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_7Prime,_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7Prime,_8Prime>` | Tuple8.`biMap(Fn1<? super _7,? extends _7Prime> lFn, Fn1<? super _8,? extends _8Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_7Prime,_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7Prime,_8Prime>` | Tuple8.`biMap(Fn1<? super _7,? extends _7Prime> lFn, Fn1<? super _8,? extends _8Prime> rFn)` Dually map covariantly over both the left and right parameters.
    `<_1Prime> Tuple2<_1Prime,_2>` | Tuple2.`biMapL(Fn1<? super _1,? extends _1Prime> fn)` Covariantly map over the left parameter.
    `<_2Prime> Tuple3<_1,_2Prime,_3>` | Tuple3.`biMapL(Fn1<? super _2,? extends _2Prime> fn)` Covariantly map over the left parameter.
    `<_3Prime> Tuple4<_1,_2,_3Prime,_4>` | Tuple4.`biMapL(Fn1<? super _3,? extends _3Prime> fn)` Covariantly map over the left parameter.
    `<_4Prime> Tuple5<_1,_2,_3,_4Prime,_5>` | Tuple5.`biMapL(Fn1<? super _4,? extends _4Prime> fn)` Covariantly map over the left parameter.
    `<_5Prime> Tuple6<_1,_2,_3,_4,_5Prime,_6>` | Tuple6.`biMapL(Fn1<? super _5,? extends _5Prime> fn)` Covariantly map over the left parameter.
    `<_6Prime> Tuple7<_1,_2,_3,_4,_5,_6Prime,_7>` | Tuple7.`biMapL(Fn1<? super _6,? extends _6Prime> fn)` Covariantly map over the left parameter.
    `<_7Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7Prime,_8>` | Tuple8.`biMapL(Fn1<? super _7,? extends _7Prime> fn)` Covariantly map over the left parameter.
    `<_2Prime> Tuple2<_1,_2Prime>` | Tuple2.`biMapR(Fn1<? super _2,? extends _2Prime> fn)` Covariantly map over the right parameter.
    `<_3Prime> Tuple3<_1,_2,_3Prime>` | Tuple3.`biMapR(Fn1<? super _3,? extends _3Prime> fn)` Covariantly map over the right parameter.
    `<_4Prime> Tuple4<_1,_2,_3,_4Prime>` | Tuple4.`biMapR(Fn1<? super _4,? extends _4Prime> fn)` Covariantly map over the right parameter.
    `<_5Prime> Tuple5<_1,_2,_3,_4,_5Prime>` | Tuple5.`biMapR(Fn1<? super _5,? extends _5Prime> fn)` Covariantly map over the right parameter.
    `<_6Prime> Tuple6<_1,_2,_3,_4,_5,_6Prime>` | Tuple6.`biMapR(Fn1<? super _6,? extends _6Prime> fn)` Covariantly map over the right parameter.
    `<_7Prime> Tuple7<_1,_2,_3,_4,_5,_6,_7Prime>` | Tuple7.`biMapR(Fn1<? super _7,? extends _7Prime> fn)` Covariantly map over the right parameter.
    `<_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime>` | Tuple8.`biMapR(Fn1<? super _8,? extends _8Prime> fn)` Covariantly map over the right parameter.
    `Tuple2<_1,_2>` | Tuple2.`censor(Fn1<? super _1,? extends _1> fn)` Update the accumulated state.
    `<_1Prime> SingletonHList<_1Prime>` | SingletonHList.`flatMap(Fn1<? super _1,? extends Monad<_1Prime,SingletonHList<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_2Prime> Tuple2<_1,_2Prime>` | Tuple2.`flatMap(Fn1<? super _2,? extends Monad<_2Prime,Tuple2<_1,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_3Prime> Tuple3<_1,_2,_3Prime>` | Tuple3.`flatMap(Fn1<? super _3,? extends Monad<_3Prime,Tuple3<_1,_2,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_4Prime> Tuple4<_1,_2,_3,_4Prime>` | Tuple4.`flatMap(Fn1<? super _4,? extends Monad<_4Prime,Tuple4<_1,_2,_3,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_5Prime> Tuple5<_1,_2,_3,_4,_5Prime>` | Tuple5.`flatMap(Fn1<? super _5,? extends Monad<_5Prime,Tuple5<_1,_2,_3,_4,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_6Prime> Tuple6<_1,_2,_3,_4,_5,_6Prime>` | Tuple6.`flatMap(Fn1<? super _6,? extends Monad<_6Prime,Tuple6<_1,_2,_3,_4,_5,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_7Prime> Tuple7<_1,_2,_3,_4,_5,_6,_7Prime>` | Tuple7.`flatMap(Fn1<? super _7,? extends Monad<_7Prime,Tuple7<_1,_2,_3,_4,_5,_6,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime>` | Tuple8.`flatMap(Fn1<? super _8,? extends Monad<_8Prime,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<_1Prime> SingletonHList<_1Prime>` | SingletonHList.`fmap(Fn1<? super _1,? extends _1Prime> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<_2Prime> Tuple2<_1,_2Prime>` | Tuple2.`fmap(Fn1<? super _2,? extends _2Prime> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<_3Prime> Tuple3<_1,_2,_3Prime>` | Tuple3.`fmap(Fn1<? super _3,? extends _3Prime> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<_4Prime> Tuple4<_1,_2,_3,_4Prime>` | Tuple4.`fmap(Fn1<? super _4,? extends _4Prime> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<_5Prime> Tuple5<_1,_2,_3,_4,_5Prime>` | Tuple5.`fmap(Fn1<? super _5,? extends _5Prime> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<_6Prime> Tuple6<_1,_2,_3,_4,_5,_6Prime>` | Tuple6.`fmap(Fn1<? super _6,? extends _6Prime> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<_7Prime> Tuple7<_1,_2,_3,_4,_5,_6,_7Prime>` | Tuple7.`fmap(Fn1<? super _7,? extends _7Prime> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime>` | Tuple8.`fmap(Fn1<? super _8,? extends _8Prime> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<R> R` | SingletonHList.`into(Fn1<? super _1,? extends R> fn)` Apply `HList.HCons.head()` to `fn` and return the result.
    `<_3> Tuple2<_1,Tuple2<_2,_3>>` | Tuple2.`listens(Fn1<? super _1,? extends _3> fn)` Map the accumulation into a value and pair it with the current output.
    `<_1Prime> SingletonHList<_1Prime>` | SingletonHList.`trampolineM(Fn1<? super _1,? extends MonadRec<RecursiveResult<_1,_1Prime>,SingletonHList<?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<_2Prime> Tuple2<_1,_2Prime>` | Tuple2.`trampolineM(Fn1<? super _2,? extends MonadRec<RecursiveResult<_2,_2Prime>,Tuple2<_1,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<_3Prime> Tuple3<_1,_2,_3Prime>` | Tuple3.`trampolineM(Fn1<? super _3,? extends MonadRec<RecursiveResult<_3,_3Prime>,Tuple3<_1,_2,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<_4Prime> Tuple4<_1,_2,_3,_4Prime>` | Tuple4.`trampolineM(Fn1<? super _4,? extends MonadRec<RecursiveResult<_4,_4Prime>,Tuple4<_1,_2,_3,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<_5Prime> Tuple5<_1,_2,_3,_4,_5Prime>` | Tuple5.`trampolineM(Fn1<? super _5,? extends MonadRec<RecursiveResult<_5,_5Prime>,Tuple5<_1,_2,_3,_4,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<_6Prime> Tuple6<_1,_2,_3,_4,_5,_6Prime>` | Tuple6.`trampolineM(Fn1<? super _6,? extends MonadRec<RecursiveResult<_6,_6Prime>,Tuple6<_1,_2,_3,_4,_5,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<_7Prime> Tuple7<_1,_2,_3,_4,_5,_6,_7Prime>` | Tuple7.`trampolineM(Fn1<? super _7,? extends MonadRec<RecursiveResult<_7,_7Prime>,Tuple7<_1,_2,_3,_4,_5,_6,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime>` | Tuple8.`trampolineM(Fn1<? super _8,? extends MonadRec<RecursiveResult<_8,_8Prime>,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,SingletonHList<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | SingletonHList.`traverse(Fn1<? super _1,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,SingletonHList<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | SingletonHList.`traverse(Fn1<? super _1,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_2Prime,App extends Applicative<?,App>,TravB extends Traversable<_2Prime,Tuple2<_1,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple2.`traverse(Fn1<? super _2,? extends Applicative<_2Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_2Prime,App extends Applicative<?,App>,TravB extends Traversable<_2Prime,Tuple2<_1,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple2.`traverse(Fn1<? super _2,? extends Applicative<_2Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_3Prime,App extends Applicative<?,App>,TravB extends Traversable<_3Prime,Tuple3<_1,_2,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple3.`traverse(Fn1<? super _3,? extends Applicative<_3Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_3Prime,App extends Applicative<?,App>,TravB extends Traversable<_3Prime,Tuple3<_1,_2,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple3.`traverse(Fn1<? super _3,? extends Applicative<_3Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_4Prime,App extends Applicative<?,App>,TravB extends Traversable<_4Prime,Tuple4<_1,_2,_3,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple4.`traverse(Fn1<? super _4,? extends Applicative<_4Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_4Prime,App extends Applicative<?,App>,TravB extends Traversable<_4Prime,Tuple4<_1,_2,_3,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple4.`traverse(Fn1<? super _4,? extends Applicative<_4Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_5Prime,App extends Applicative<?,App>,TravB extends Traversable<_5Prime,Tuple5<_1,_2,_3,_4,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple5.`traverse(Fn1<? super _5,? extends Applicative<_5Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_5Prime,App extends Applicative<?,App>,TravB extends Traversable<_5Prime,Tuple5<_1,_2,_3,_4,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple5.`traverse(Fn1<? super _5,? extends Applicative<_5Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_6Prime,App extends Applicative<?,App>,TravB extends Traversable<_6Prime,Tuple6<_1,_2,_3,_4,_5,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple6.`traverse(Fn1<? super _6,? extends Applicative<_6Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_6Prime,App extends Applicative<?,App>,TravB extends Traversable<_6Prime,Tuple6<_1,_2,_3,_4,_5,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple6.`traverse(Fn1<? super _6,? extends Applicative<_6Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_7Prime,App extends Applicative<?,App>,TravB extends Traversable<_7Prime,Tuple7<_1,_2,_3,_4,_5,_6,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple7.`traverse(Fn1<? super _7,? extends Applicative<_7Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_7Prime,App extends Applicative<?,App>,TravB extends Traversable<_7Prime,Tuple7<_1,_2,_3,_4,_5,_6,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple7.`traverse(Fn1<? super _7,? extends Applicative<_7Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_8Prime,App extends Applicative<?,App>,TravB extends Traversable<_8Prime,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple8.`traverse(Fn1<? super _8,? extends Applicative<_8Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<_8Prime,App extends Applicative<?,App>,TravB extends Traversable<_8Prime,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Tuple8.`traverse(Fn1<? super _8,? extends Applicative<_8Prime,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.

    Method parameters in com.jnape.palatable.lambda.adt.hlist with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<_1Prime> Lazy<SingletonHList<_1Prime>>` | SingletonHList.`lazyZip(Lazy<? extends Applicative<Fn1<? super _1,? extends _1Prime>,SingletonHList<?>>> 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.
    `<_2Prime> Lazy<Tuple2<_1,_2Prime>>` | Tuple2.`lazyZip(Lazy<? extends Applicative<Fn1<? super _2,? extends _2Prime>,Tuple2<_1,?>>> 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.
    `<_3Prime> Lazy<Tuple3<_1,_2,_3Prime>>` | Tuple3.`lazyZip(Lazy<? extends Applicative<Fn1<? super _3,? extends _3Prime>,Tuple3<_1,_2,?>>> 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.
    `<_4Prime> Lazy<Tuple4<_1,_2,_3,_4Prime>>` | Tuple4.`lazyZip(Lazy<? extends Applicative<Fn1<? super _4,? extends _4Prime>,Tuple4<_1,_2,_3,?>>> 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.
    `<_5Prime> Lazy<Tuple5<_1,_2,_3,_4,_5Prime>>` | Tuple5.`lazyZip(Lazy<? extends Applicative<Fn1<? super _5,? extends _5Prime>,Tuple5<_1,_2,_3,_4,?>>> 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.
    `<_6Prime> Lazy<Tuple6<_1,_2,_3,_4,_5,_6Prime>>` | Tuple6.`lazyZip(Lazy<? extends Applicative<Fn1<? super _6,? extends _6Prime>,Tuple6<_1,_2,_3,_4,_5,?>>> 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.
    `<_7Prime> Lazy<Tuple7<_1,_2,_3,_4,_5,_6,_7Prime>>` | Tuple7.`lazyZip(Lazy<? extends Applicative<Fn1<? super _7,? extends _7Prime>,Tuple7<_1,_2,_3,_4,_5,_6,?>>> 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.
    `<_8Prime> Lazy<Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime>>` | Tuple8.`lazyZip(Lazy<? extends Applicative<Fn1<? super _8,? extends _8Prime>,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>> 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.
    `<_1Prime> SingletonHList<_1Prime>` | SingletonHList.`zip(Applicative<Fn1<? super _1,? extends _1Prime>,SingletonHList<?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<_2Prime> Tuple2<_1,_2Prime>` | Tuple2.`zip(Applicative<Fn1<? super _2,? extends _2Prime>,Tuple2<_1,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<_3Prime> Tuple3<_1,_2,_3Prime>` | Tuple3.`zip(Applicative<Fn1<? super _3,? extends _3Prime>,Tuple3<_1,_2,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<_4Prime> Tuple4<_1,_2,_3,_4Prime>` | Tuple4.`zip(Applicative<Fn1<? super _4,? extends _4Prime>,Tuple4<_1,_2,_3,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<_5Prime> Tuple5<_1,_2,_3,_4,_5Prime>` | Tuple5.`zip(Applicative<Fn1<? super _5,? extends _5Prime>,Tuple5<_1,_2,_3,_4,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<_6Prime> Tuple6<_1,_2,_3,_4,_5,_6Prime>` | Tuple6.`zip(Applicative<Fn1<? super _6,? extends _6Prime>,Tuple6<_1,_2,_3,_4,_5,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<_7Prime> Tuple7<_1,_2,_3,_4,_5,_6,_7Prime>` | Tuple7.`zip(Applicative<Fn1<? super _7,? extends _7Prime>,Tuple7<_1,_2,_3,_4,_5,_6,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime>` | Tuple8.`zip(Applicative<Fn1<? super _8,? extends _8Prime>,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>> 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 Fn1 in com.jnape.palatable.lambda.functions

    Subinterfaces of Fn1 in com.jnape.palatable.lambda.functions
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Effect<A>` A function returning "no result", and therefore only useful as a side-effect.
    `interface` | `Fn0<A>` A function taking "no arguments", implemented as an ``Fn1`<`Unit`, A>`.
    `interface` | `Fn2<A,B,C>` A function taking two arguments.
    `interface` | `Fn3<A,B,C,D>` A function taking three arguments.
    `interface` | `Fn4<A,B,C,D,E>` A function taking four arguments.
    `interface` | `Fn5<A,B,C,D,E,F>` A function taking five arguments.
    `interface` | `Fn6<A,B,C,D,E,F,G>` A function taking six arguments.
    `interface` | `Fn7<A,B,C,D,E,F,G,H>` A function taking six arguments.
    `interface` | `Fn8<A,B,C,D,E,F,G,H,I>` A function taking six arguments.

    Methods in com.jnape.palatable.lambda.functions that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default Fn1<B,C>` | Fn2.`apply(A a)` Partially apply this function by passing its first argument.
    `default Fn1<C,D>` | Fn3.`apply(A a, B b)` Partially apply this function by taking its first two arguments.
    `default Fn1<D,E>` | Fn4.`apply(A a, B b, C c)` Partially apply this function by taking its first three arguments.
    `default Fn1<E,F>` | Fn5.`apply(A a, B b, C c, D d)` Partially apply this function by taking its first four arguments.
    `default Fn1<F,G>` | Fn6.`apply(A a, B b, C c, D d, E e)` Partially apply this function by taking its first five arguments.
    `default Fn1<G,H>` | Fn7.`apply(A a, B b, C c, D d, E e, F f)` Partially apply this function by taking its first six arguments.
    `default Fn1<H,I>` | Fn8.`apply(A a, B b, C c, D d, E e, F f, G g)` Partially apply this function by taking its first seven arguments.
    `default Fn1<A,Tuple2<A,B>>` | Fn1.`carry()` Pair the covariantly-positioned carrier type with the contravariantly-positioned carrier type.
    `default <C> Fn1<Tuple2<C,A>,Tuple2<C,B>>` | Fn1.`cartesian()` Pair a value with the input to this function, and preserve the paired value through to the output.
    `default Fn1<A,B>` | Fn1.`censor(Fn1<? super A,? extends A> fn)` Update the accumulated state.
    `default Fn1<B,C>` | Fn2.`checkedApply(A a)` Invoke this function with the given argument, potentially throwing any `Throwable`.
    `default Fn1<C,D>` | Fn3.`checkedApply(A a, B b)`
    `default Fn1<D,E>` | Fn4.`checkedApply(A a, B b, C c)`
    `default Fn1<E,F>` | Fn5.`checkedApply(A a, B b, C c, D d)`
    `default Fn1<F,G>` | Fn6.`checkedApply(A a, B b, C c, D d, E e)`
    `default Fn1<G,H>` | Fn7.`checkedApply(A a, B b, C c, D d, E e, F f)`
    `default Fn1<H,I>` | Fn8.`checkedApply(A a, B b, C c, D d, E e, F f, G g)`
    `default Fn1<A,Choice2<A,B>>` | Fn1.`choose()` Choose between a successful result `b` or returning back the input, `a`.
    `default <C> Fn1<Choice2<C,A>,Choice2<C,B>>` | Fn1.`cocartesian()` Choose between either applying this function or returning back a different result altogether.
    `default <Z> Fn1<Z,B>` | Fn1.`contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `default <Z,C> Fn1<Z,C>` | Fn1.`diMap(Fn1<? super Z,? extends A> lFn, Fn1<? super B,? extends C> rFn)` Exercise both `diMapL` and `diMapR` over this function in the same invocation.
    `default <Z> Fn1<Z,B>` | Fn1.`diMapL(Fn1<? super Z,? extends A> fn)` Contravariantly map over the argument to this function, producing a function that takes the new argument type, and produces the same result.
    `default <C> Fn1<A,C>` | Fn1.`diMapR(Fn1<? super B,? extends C> fn)` Covariantly map over the return value of this function, producing a function that takes the same argument, and produces the new result type.
    `default <C> Fn1<A,C>` | Fn1.`discardL(Applicative<C,Fn1<A,?>> appB)` Sequence both this `Applicative` and `appB`, discarding this `Applicative's` result and returning `appB`.
    `default <C> Fn1<A,B>` | Fn1.`discardR(Applicative<C,Fn1<A,?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `default <C> Fn1<A,C>` | Fn1.`flatMap(Fn1<? super B,? extends Monad<C,Fn1<A,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `default <C> Fn1<A,C>` | Fn1.`fmap(Fn1<? super B,? extends C> f)` Also left-to-right composition (sadly).
    `static <A,B> Fn1<A,B>` | Fn1.`fn1(Fn1<? super A,? extends B> fn)` Static factory method for avoid explicit casting when using method references as `Fn1`s.
    `static <A,B> Fn1<A,B>` | Fn1.`fromFunction(Function<? super A,? extends B> function)` Static factory method for wrapping a java `Function` in an `Fn1`.
    `default <C> Fn1<A,Tuple2<B,C>>` | Fn1.`listens(Fn1<? super A,? extends C> fn)` Map the accumulation into a value and pair it with the current output.
    `default Fn1<A,B>` | Fn1.`local(Fn1<? super A,? extends A> fn)` Modify this `MonadReader's` environment after reading it but before running the effect.
    `default <C> Fn1<A,C>` | Fn1.`pure(C c)` Lift the value `b` into this applicative functor.
    `default <C> Fn1<A,C>` | Fn1.`trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Fn1<A,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `default Fn1<? super Product2<? extends A,? extends B>,C>` | Fn2.`uncurry()` Returns an `Fn1` that takes the arguments as a ``Product2`<A, B>`.
    `default <C> Fn1<A,C>` | Fn1.`zip(Applicative<Fn1<? super B,? extends C>,Fn1<A,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `default <C> Fn1<A,C>` | Fn1.`zip(Fn2<A,B,C> appFn)`

    Methods in com.jnape.palatable.lambda.functions that return types with arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default <Y,Z> Fn8<Y,Z,B,C,D,E,F,G,Fn1<H,I>>` | Fn8.`compose(Fn2<? super Y,? super Z,? extends A> before)`
    `default <C> Lazy<Fn1<A,C>>` | Fn1.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Fn1<A,?>>> 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 <A> Pure<Fn1<A,?>>` | Fn1.`pureFn1()` The canonical `Pure` instance for `Fn1`.

    Methods in com.jnape.palatable.lambda.functions with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default Fn1<A,B>` | Fn1.`censor(Fn1<? super A,? extends A> fn)` Update the accumulated state.
    `default <Z> Fn5<Z,B,C,D,E,F>` | Fn5.`contraMap(Fn1<? super Z,? extends A> fn)`
    `default <Z> Fn8<Z,B,C,D,E,F,G,H,I>` | Fn8.`contraMap(Fn1<? super Z,? extends A> fn)`
    `default <Z> Fn4<Z,B,C,D,E>` | Fn4.`contraMap(Fn1<? super Z,? extends A> fn)`
    `default <Z> Effect<Z>` | Effect.`contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `default <Z> Fn2<Z,B,C>` | Fn2.`contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `default <Z> Fn1<Z,B>` | Fn1.`contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `default <Z> Fn3<Z,B,C,D>` | Fn3.`contraMap(Fn1<? super Z,? extends A> fn)`
    `default <Z> Fn6<Z,B,C,D,E,F,G>` | Fn6.`contraMap(Fn1<? super Z,? extends A> fn)`
    `default <Z> Fn7<Z,B,C,D,E,F,G,H>` | Fn7.`contraMap(Fn1<? super Z,? extends A> fn)`
    `static <A,B,C> Fn2<A,B,C>` | Fn2.`curried(Fn1<A,Fn1<B,C>> curriedFn1)` Static factory method for wrapping a curried `Fn1` in an `Fn2`.
    `static <A,B,C> Fn2<A,B,C>` | Fn2.`curry(Fn1<? super Tuple2<A,B>,? extends C> uncurriedFn1)` Static factory method for wrapping an uncurried `Fn1` in an `Fn2`.
    `default <Z,C> Fn1<Z,C>` | Fn1.`diMap(Fn1<? super Z,? extends A> lFn, Fn1<? super B,? extends C> rFn)` Exercise both `diMapL` and `diMapR` over this function in the same invocation.
    `default <Z,C> Fn1<Z,C>` | Fn1.`diMap(Fn1<? super Z,? extends A> lFn, Fn1<? super B,? extends C> rFn)` Exercise both `diMapL` and `diMapR` over this function in the same invocation.
    `default <Z> Fn5<Z,B,C,D,E,F>` | Fn5.`diMapL(Fn1<? super Z,? extends A> fn)`
    `default <Z> Fn8<Z,B,C,D,E,F,G,H,I>` | Fn8.`diMapL(Fn1<? super Z,? extends A> fn)`
    `default <Z> Fn4<Z,B,C,D,E>` | Fn4.`diMapL(Fn1<? super Z,? extends A> fn)`
    `default <Z> Effect<Z>` | Effect.`diMapL(Fn1<? super Z,? extends A> fn)` Contravariantly map over the argument to this function, producing a function that takes the new argument type, and produces the same result.
    `default <Z> Fn2<Z,B,C>` | Fn2.`diMapL(Fn1<? super Z,? extends A> fn)` Contravariantly map over the argument to this function, producing a function that takes the new argument type, and produces the same result.
    `default <Z> Fn1<Z,B>` | Fn1.`diMapL(Fn1<? super Z,? extends A> fn)` Contravariantly map over the argument to this function, producing a function that takes the new argument type, and produces the same result.
    `default <Z> Fn3<Z,B,C,D>` | Fn3.`diMapL(Fn1<? super Z,? extends A> fn)`
    `default <Z> Fn6<Z,B,C,D,E,F,G>` | Fn6.`diMapL(Fn1<? super Z,? extends A> fn)`
    `default <Z> Fn7<Z,B,C,D,E,F,G,H>` | Fn7.`diMapL(Fn1<? super Z,? extends A> fn)`
    `default <B> Fn0<B>` | Fn0.`diMapR(Fn1<? super A,? extends B> fn)`
    `default <C> Fn1<A,C>` | Fn1.`diMapR(Fn1<? super B,? extends C> fn)` Covariantly map over the return value of this function, producing a function that takes the same argument, and produces the new result type.
    `static <A> Effect<A>` | Effect.`effect(Fn1<? super A,? extends IO<?>> fn)` Create an `Effect` from an `Fn1` that yields an `IO`.
    `default <B> Fn0<B>` | Fn0.`flatMap(Fn1<? super A,? extends Monad<B,Fn1<Unit,?>>> f)`
    `default <C> Fn1<A,C>` | Fn1.`flatMap(Fn1<? super B,? extends Monad<C,Fn1<A,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `default <B> Fn0<B>` | Fn0.`fmap(Fn1<? super A,? extends B> f)`
    `default <C> Fn1<A,C>` | Fn1.`fmap(Fn1<? super B,? extends C> f)` Also left-to-right composition (sadly).
    `static <A> Fn0<A>` | Fn0.`fn0(Fn1<Unit,A> fn)` Static factory method for adapting an ``Fn1`<Unit, A>` to an ``Fn0`<A>`.
    `static <A,B> Fn1<A,B>` | Fn1.`fn1(Fn1<? super A,? extends B> fn)` Static factory method for avoid explicit casting when using method references as `Fn1`s.
    `static <A,B,C,D> Fn3<A,B,C,D>` | Fn3.`fn3(Fn1<A,Fn2<B,C,D>> curriedFn1)` Static factory method for wrapping a curried `Fn1` in an `Fn3`.
    `static <A,B,C,D,E> Fn4<A,B,C,D,E>` | Fn4.`fn4(Fn1<A,Fn3<B,C,D,E>> curriedFn1)` Static factory method for wrapping a curried `Fn1` in an `Fn4`.
    `static <A,B,C,D,E,F> Fn5<A,B,C,D,E,F>` | Fn5.`fn5(Fn1<A,Fn4<B,C,D,E,F>> curriedFn1)` Static factory method for wrapping a curried `Fn1` in an `Fn5`.
    `static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G>` | Fn6.`fn6(Fn1<A,Fn5<B,C,D,E,F,G>> curriedFn1)` Static factory method for wrapping a curried `Fn1` in an `Fn6`.
    `static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H>` | Fn7.`fn7(Fn1<A,Fn6<B,C,D,E,F,G,H>> curriedFn1)` Static factory method for wrapping a curried `Fn1` in an `Fn7`.
    `static <A,B,C,D,E,F,G,H,I> Fn8<A,B,C,D,E,F,G,H,I>` | Fn8.`fn8(Fn1<A,Fn7<B,C,D,E,F,G,H,I>> curriedFn1)` Static factory method for wrapping a curried `Fn1` in an `Fn8`.
    `default <C> Fn1<A,Tuple2<B,C>>` | Fn1.`listens(Fn1<? super A,? extends C> fn)` Map the accumulation into a value and pair it with the current output.
    `default Fn1<A,B>` | Fn1.`local(Fn1<? super A,? extends A> fn)` Modify this `MonadReader's` environment after reading it but before running the effect.
    `default <C> Fn1<A,C>` | Fn1.`trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Fn1<A,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.

    Method parameters in com.jnape.palatable.lambda.functions with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B,C> Fn2<A,B,C>` | Fn2.`curried(Fn1<A,Fn1<B,C>> curriedFn1)` Static factory method for wrapping a curried `Fn1` in an `Fn2`.
    `default <B> Fn0<B>` | Fn0.`discardL(Applicative<B,Fn1<Unit,?>> appB)`
    `default <C> Fn1<A,C>` | Fn1.`discardL(Applicative<C,Fn1<A,?>> appB)` Sequence both this `Applicative` and `appB`, discarding this `Applicative's` result and returning `appB`.
    `default <B> Fn0<A>` | Fn0.`discardR(Applicative<B,Fn1<Unit,?>> appB)`
    `default <C> Effect<A>` | Effect.`discardR(Applicative<C,Fn1<A,?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `default <C> Fn1<A,B>` | Fn1.`discardR(Applicative<C,Fn1<A,?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `default <D> Fn2<A,B,C>` | Fn2.`discardR(Applicative<D,Fn1<A,?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `default <E> Fn3<A,B,C,D>` | Fn3.`discardR(Applicative<E,Fn1<A,?>> appB)`
    `default <F> Fn4<A,B,C,D,E>` | Fn4.`discardR(Applicative<F,Fn1<A,?>> appB)`
    `default <G> Fn5<A,B,C,D,E,F>` | Fn5.`discardR(Applicative<G,Fn1<A,?>> appB)`
    `default <H> Fn6<A,B,C,D,E,F,G>` | Fn6.`discardR(Applicative<H,Fn1<A,?>> appB)`
    `default <I> Fn7<A,B,C,D,E,F,G,H>` | Fn7.`discardR(Applicative<I,Fn1<A,?>> appB)`
    `default <J> Fn8<A,B,C,D,E,F,G,H,I>` | Fn8.`discardR(Applicative<J,Fn1<A,?>> appB)`
    `default <B> Fn0<B>` | Fn0.`flatMap(Fn1<? super A,? extends Monad<B,Fn1<Unit,?>>> f)`
    `default <C> Fn1<A,C>` | Fn1.`flatMap(Fn1<? super B,? extends Monad<C,Fn1<A,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `static <A,B,C,D> Fn3<A,B,C,D>` | Fn3.`fn3(Fn2<A,B,Fn1<C,D>> curriedFn2)` Static factory method for wrapping a curried `Fn2` in an `Fn3`.
    `static <A,B,C,D,E> Fn4<A,B,C,D,E>` | Fn4.`fn4(Fn3<A,B,C,Fn1<D,E>> curriedFn3)` Static factory method for wrapping a curried `Fn3` in an `Fn4`.
    `static <A,B,C,D,E,F> Fn5<A,B,C,D,E,F>` | Fn5.`fn5(Fn4<A,B,C,D,Fn1<E,F>> curriedFn4)` Static factory method for wrapping a curried `Fn4` in an `Fn5`.
    `static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G>` | Fn6.`fn6(Fn5<A,B,C,D,E,Fn1<F,G>> curriedFn5)` Static factory method for wrapping a curried `Fn5` in an `Fn6`.
    `static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H>` | Fn7.`fn7(Fn6<A,B,C,D,E,F,Fn1<G,H>> curriedFn6)` Static factory method for wrapping a curried `Fn6` in an `Fn7`.
    `static <A,B,C,D,E,F,G,H,I> Fn8<A,B,C,D,E,F,G,H,I>` | Fn8.`fn8(Fn7<A,B,C,D,E,F,G,Fn1<H,I>> curriedFn7)` Static factory method for wrapping a curried `Fn7` in an `Fn8`.
    `default <C> Lazy<Fn1<A,C>>` | Fn1.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Fn1<A,?>>> 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.
    `default <C> Lazy<Fn1<A,C>>` | Fn1.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Fn1<A,?>>> 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.
    `default <C> Fn1<A,C>` | Fn1.`trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Fn1<A,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `default <B> Fn0<B>` | Fn0.`zip(Applicative<Fn1<? super A,? extends B>,Fn1<Unit,?>> appFn)`
    `default <B> Fn0<B>` | Fn0.`zip(Applicative<Fn1<? super A,? extends B>,Fn1<Unit,?>> appFn)`
    `default <C> Fn1<A,C>` | Fn1.`zip(Applicative<Fn1<? super B,? extends C>,Fn1<A,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `default <C> Fn1<A,C>` | Fn1.`zip(Applicative<Fn1<? super B,? extends C>,Fn1<A,?>> 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 Fn1 in com.jnape.palatable.lambda.functions.builtin.fn1

    Classes in com.jnape.palatable.lambda.functions.builtin.fn1 that implement Fn1
    Modifier and Type | Class and Description
    --- | ---
    `class` | `CatMaybes<A>` Given an ``Iterable`<`Maybe`<A>>`, return an ``Iterable`<A>` of only the present values.
    `class` | `Coalesce<L,R>` Fold an ``Iterable`<`Either`<L, R>>` into an ``Either`<`Iterable`<L>, `Iterable`<R>>`, preserving all results of the side that's returned.
    `class` | `Constantly<A,B>` A function that takes two arguments and always returns the first argument.
    `class` | `Cycle<A>` Given an `Iterable`, return an infinite `Iterable` that repeatedly cycles its elements, in order.
    `class` | `Distinct<A>` Return an `Iterable` of the distinct values from the given input `Iterable`.
    `class` | `Downcast<A extends B,B>` Covariantly cast a value of type `B` to a value of subtype `A`.
    `class` | `Empty<A>` A predicate that returns true if `as` is empty; false otherwise.
    `class` | `Flatten<A>` Given a nested `Iterable` of `Iterable`s, return a lazily flattening `Iterable` of the nested elements.
    `class` | `Force<A>` Deprecated. in favor of `traversing` into an `IO` and running it
    `class` | `Head<A>` Retrieve the head element of an `Iterable`, wrapped in an `Maybe`.
    `class` | `Id<A>` The identity function.
    `class` | `Init<A>` Given an ``Iterable`<A>`, produce an ``Iterable`<A>` of all elements but the last one.
    `class` | `Inits<A>` Given an ``Iterable`<A>`, produce an ``Iterable`<`Iterable`<A>>`, representing all of the subsequences of initial elements, ordered by size, starting with the empty `Iterable`.
    `class` | `Last<A>` Retrieve the last element of an `Iterable`, wrapped in a `Maybe`.
    `class` | `Magnetize<A>` `Magnetize` an `Iterable` using value equality as the magnetizing function.
    `class` | `Not<A>` Negate a predicate function.
    `class` | `Occurrences<A>` Given an ``Iterable`<A>`, return a ``Map`<A, Long>` representing each unique element in the `Iterable` paired with its number of occurrences.
    `class` | `Repeat<A>` Given a value, return an infinite `Iterable` that repeatedly iterates that value.
    `class` | `Reverse<A>` Given an `Iterable`, return a reversed representation of that `Iterable`.
    `class` | `Size`
    `class` | `Sort<A extends Comparable<A>>` Given an `Iterable` of `Comparable` elements, return a `List` of the sorted elements.
    `class` | `Tail<A>` Returns the tail of an `Iterable`; the is, an `Iterable` of all the elements except for the head element.
    `class` | `Tails<A>` Given an ``Iterable`<A>`, produce an ``Iterable`<`Iterable`<A>>`, representing all of the subsequences of tail elements, ordered by size, starting with the full `Iterable`.
    `class` | `Uncons<A>` Destructure an `Iterable` into a `Tuple2` of its head and tail, wrapped in an `Maybe`.
    `class` | `Upcast<A extends B,B>` Upcast a value of type `B` to a value of type `A` that `B` extends.

    Methods in com.jnape.palatable.lambda.functions.builtin.fn1 that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B> Fn1<B,A>` | Constantly.`constantly(A a)`

    Methods in com.jnape.palatable.lambda.functions.builtin.fn1 with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `Boolean` | Not.`checkedApply(Fn1<? super A,? extends Boolean> pred, A a)`
    `static <A> Predicate<A>` | Not.`not(Fn1<? super A,? extends Boolean> pred)`
    `static <A> Boolean` | Not.`not(Fn1<? super A,? extends Boolean> pred, A a)`

  - ### Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn2

    Classes in com.jnape.palatable.lambda.functions.builtin.fn2 that implement Fn1
    Modifier and Type | Class and Description
    --- | ---
    `class` | `All<A>` Eagerly apply a predicate to each element in an `Iterable`, returning `true` if every element satisfies the predicate, and `false` otherwise.
    `class` | `Alter<A>` Given an ``Effect`<A>` and some `A`, produce an `IO` that, when run, performs the effect on `A` and returns it.
    `class` | `Any<A>` Eagerly apply a predicate to each element in an `Iterable`, returning `true` if any element satisfies the predicate, and `false` otherwise.
    `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.
    `class` | `Both<A,B,C>` Given two functions `f` and `g`, produce a ``Fn1`<A, `Tuple2`<B, C>>` (the dual application of both functions).
    `class` | `CartesianProduct<A,B>` Lazily compute the cartesian product of an `Iterable<A>` and `Iterable<B>`, returning an `Iterable<Tuple2<A, B>>`, the products as tuples of multiplicand `A`s and multiplier `B`s.
    `class` | `CmpEq<A extends Comparable<A>>` Given two `Comparable` values of type `A`, return `true` if the first value is strictly equal to the second value (according to `Comparable.compareTo(Object)`; otherwise, return false.
    `class` | `Cons<A>` Prepend an element to an `Iterable`.
    `class` | `Difference<A>` Given two `Iterables` `xs` and `ys`, return the `distinct` elements of `xs` that are not in `ys`.
    `class` | `Drop<A>` Lazily skip the first `n` elements from an `Iterable` by returning an `Iterable` that begins iteration after the `nth` element.
    `class` | `DropWhile<A>` Lazily limit the `Iterable` by skipping the first contiguous group of elements that satisfy the predicate, beginning iteration at the first element for which the predicate evaluates to `false`.
    `class` | `Eq<A>` Type-safe equality in function form; uses `Object.equals(java.lang.Object)`, not `==`.
    `class` | `Filter<A>` Lazily apply a predicate to each element in an `Iterable`, returning an `Iterable` of just the elements for which the predicate evaluated to `true`.
    `class` | `Find<A>` Iterate the elements in an `Iterable`, applying a predicate to each one, returning the first element that matches the predicate, wrapped in a `Maybe`.
    `class` | `GroupBy<K,V>` Given an `Iterable<V>` `vs` and a key function `V -> K` `f`, fold `vs` into a `Map<K, List<V>>` by applying `f` to each element of `vs`, retaining values that map to the same key in a list, in the order they were iterated in.
    `class` | `GT<A extends Comparable<A>>` Given two `Comparable` values of type `A`, return `true` if the second value is strictly greater than the first value; otherwise, return false.
    `class` | `GTE<A extends Comparable<A>>` Given two `Comparable` values of type `A`, return `true` if the second value is greater than or equal to the first value according to `Comparable.compareTo(Object)`; otherwise, return false.
    `class` | `InGroupsOf<A>` Lazily group the `Iterable` by returning an `Iterable` of smaller `Iterable`s of size `k`.
    `class` | `Intersperse<A>` Lazily inject the provided separator value between each value in the supplied `Iterable`.
    `class` | `Into<A,B,C>` Given an ``Fn2`<A, B, C>` and a ``Map.Entry`<A, B>`, destructure the entry and apply the key and value as arguments to the function, returning the result.
    `class` | `Into1<A,B>` Given an ``Fn1`<A, B>` and a ``SingletonHList`<A>`, pop the head and apply it to the function, returning the result.
    `class` | `Into3<A,B,C,D>` Given an ``Fn3`<A, B, C, D>` and a ``Product3`<A, B, C>`, destructure the product and apply the slots as arguments to the function, returning the result.
    `class` | `Into4<A,B,C,D,E>` Given an ``Fn4`<A, B, C, D, E>` and a ``Product4`<A, B, C, D>`, destructure the product and apply the slots as arguments to the function, returning the result.
    `class` | `Into5<A,B,C,D,E,F>` Given an ``Fn5`<A, B, C, D, E, F>` and a ``Product5`<A, B, C, D, E>`, destructure the product and apply the slots as arguments to the function, returning the result.
    `class` | `Into6<A,B,C,D,E,F,G>` Given an ``Fn6`<A, B, C, D, E, F, G>` and a ``Product6`<A, B, C, D, E, F>`, destructure the product and apply the slots as arguments to the function, returning the result.
    `class` | `Into7<A,B,C,D,E,F,G,H>` Given an ``Fn7`<A, B, C, D, E, F, G, H>` and a ``Product7`<A, B, C, D, E, F, G>`, destructure the product and apply the slots as arguments to the function, returning the result.
    `class` | `Into8<A,B,C,D,E,F,G,H,I>` Given an ``Fn8`<A, B, C, D, E, F, G, H, I>` and a ``Product8`<A, B, C, D, E, F, G, H>`, destructure the product and apply the slots as arguments to the function, returning the result.
    `class` | `Iterate<A>` Lazily generate an infinite `Iterable` from the successive applications of the function first to the initial seed value, then to the result, and so on; i.e., the result of `iterate(x -> x + 1, 0)` would produce an infinite `Iterable` over the elements `0, 1, 2, 3, ...`
    `class` | `LazyRec<A,B>` Given a `Fn2` that receives a recursive function and an input and yields a `lazy` result, and an input, produce a `lazy` result that, when forced, will recursively invoke the function until it terminates in a stack-safe way.
    `class` | `LT<A extends Comparable<A>>` Given two `Comparable` values of type `A`, return `true` if the second value is strictly less than the first value; otherwise, return false.
    `class` | `LTE<A extends Comparable<A>>` Given two `Comparable` values of type `A`, return `true` if the second value is less than or equal to the first value according to `Comparable.compareTo(Object)` otherwise, return false.
    `class` | `MagnetizeBy<A>` Given a binary predicate and an ``Iterable`<A>`, return an ``Iterable`<`Iterable`<A>>` of the contiguous groups of elements that match the predicate pairwise.
    `class` | `Map<A,B>` Lazily apply a function to each element in an `Iterable`, producing an `Iterable` of the mapped results.
    `class` | `Partition<A,B,C>` Given an `Iterable<A>` `as` and a disjoint mapping function `a -> CoProduct2<A, B>`, return a `Tuple2` over the lazily unwrapped left `A` and right `B` values in the first and second slots, respectively.
    `class` | `Peek<A,FA extends Functor<A,?>>` Deprecated. in favor of producing an `IO` from the given `Functor` and explicitly running it
    `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
    `class` | `PrependAll<A>` Lazily prepend each value with of the `Iterable` with the supplied separator value.
    `class` | `ReduceLeft<A>` Given an ``Iterable`<A>` and a ``Fn2`<A, A, A>`, iteratively accumulate over the `Iterable`, returning ``Maybe`<A>`.
    `class` | `ReduceRight<A>` Given an ``Iterable`<A>` and a ``Fn2`<A, A, A>`, iteratively accumulate over the `Iterable`, returning ``Maybe`<A>`.
    `class` | `Replicate<A>` Produce an `Iterable` of a value `n` times.
    `class` | `Sequence<A,App extends Applicative<?,App>,Trav extends Traversable<?,Trav>,TravA extends Traversable<A,Trav>,AppTrav extends Applicative<TravA,App>>` Given a `Traversable` of `Applicative`s and a pure `Applicative` constructor, traverse the elements from left to right, zipping the `Applicative`s together and collecting the results.
    `class` | `Slide<A>` Given an ``Iterable`<A>`, "slide" a window of `k` elements across the `Iterable` by one element at a time, returning an ``Iterable`<`Iterable`<A>>`.
    `class` | `Snoc<A>` Opposite of `Cons`: lazily append an element to the end of the given `Iterable`.
    `class` | `SortBy<A,B extends Comparable<B>>` Given an `Iterable` and some mapping function from the `Iterable` element type to some `Comparable` type, produce a sorted `List` of the original elements based on sorting applied to the result of the mapping function.
    `class` | `SortWith<A>` Given an `Iterable` and a `Comparator` over the `Iterable` element type, produce a sorted `List` of the original elements based on sorting applied by the `Comparator`.
    `class` | `Span<A>` Given a predicate, return a `Tuple2` where the first slot is the front contiguous elements of an `Iterable` matching the predicate and the second slot is all the remaining elements.
    `class` | `Take<A>` Lazily limit the `Iterable` to `n` elements by returning an `Iterable` that stops iteration after the `nth` element, or the last element of the `Iterable`, whichever comes first.
    `class` | `TakeWhile<A>` Lazily limit the `Iterable` to the first group of contiguous elements that satisfy the predicate by iterating up to, but not including, the first element for which the predicate evaluates to `false`.
    `class` | `ToArray<A>` Write all the elements of an `Iterable` directly into an array of the specified type.
    `class` | `ToCollection<A,C extends Collection<A>>` Given an `Fn0` of some `Collection` `C`, create an instance of `C` and add all of the elements in the provided `Iterable` to the instance.
    `class` | `ToMap<K,V,M extends Map<K,V>>` Given an `Fn0` of some `Map` `M`, create an instance of `M` and put all of the entries in the provided `Iterable` into the instance.
    `class` | `Tupler2<A,B>` Creates a `Tuple2` from two values.
    `class` | `Unfoldr<A,B>` Given an initial seed value and a function that takes the seed type and produces an ``Maybe`<`Tuple2`<X, Seed>>`, where the tuple's first slot represents the next `Iterable` element, and the second slot represents the next input to the unfolding function, unfold an `Iterable` of `X`s.
    `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.
    `class` | `Zip<A,B>` Zip together two `Iterable`s into a single `Iterable` of `Tuple2<A, B>`.

    Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <A> Fn1<Iterable<A>,? extends Boolean>` | All.`all(Fn1<? super A,? extends Boolean> predicate)`
    `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,B,C> Fn1<Fn1<? super A,? extends C>,Fn1<A,Tuple2<B,C>>>` | Both.`both(Fn1<? super A,? extends B> f)`
    `static <A,B,C> Fn1<A,Tuple2<B,C>>` | Both.`both(Fn1<? super A,? extends B> f, Fn1<? super A,? extends C> g)`
    `static <A,B> Fn1<Iterable<B>,Iterable<Tuple2<A,B>>>` | CartesianProduct.`cartesianProduct(Iterable<A> as)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | Cons.`cons(A a)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | Difference.`difference(Iterable<A> xs)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | Drop.`drop(int n)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | DropWhile.`dropWhile(Fn1<? super A,? extends Boolean> predicate)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | Filter.`filter(Fn1<? super A,? extends Boolean> predicate)`
    `static <A> Fn1<Iterable<A>,Maybe<A>>` | Find.`find(Fn1<? super A,? extends Boolean> predicate)`
    `static <K,V> Fn1<Iterable<V>,Map<K,List<V>>>` | GroupBy.`groupBy(Fn1<? super V,? extends K> keyFn)`
    `static <A> Fn1<Iterable<A>,Iterable<Iterable<A>>>` | InGroupsOf.`inGroupsOf(Integer k)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | Intersperse.`intersperse(A a)`
    `static <A,B,C> Fn1<Map.Entry<A,B>,C>` | Into.`into(Fn2<? super A,? super B,? extends C> fn)`
    `static <A,B> Fn1<SingletonHList<A>,B>` | Into1.`into1(Fn1<? super A,? extends B> fn)`
    `static <A,B,C,D> Fn1<Product3<A,B,C>,D>` | Into3.`into3(Fn3<? super A,? super B,? super C,? extends D> fn)`
    `static <A,B,C,D,E> Fn1<Product4<A,B,C,D>,E>` | Into4.`into4(Fn4<? super A,? super B,? super C,? super D,? extends E> fn)`
    `static <A,B,C,D,E,F> Fn1<Product5<A,B,C,D,E>,F>` | Into5.`into5(Fn5<? super A,? super B,? super C,? super D,? super E,? extends F> fn)`
    `static <A,B,C,D,E,F,G> Fn1<Product6<A,B,C,D,E,F>,G>` | Into6.`into6(Fn6<? super A,? super B,? super C,? super D,? super E,? super F,? extends G> fn)`
    `static <A,B,C,D,E,F,G,H> Fn1<Product7<A,B,C,D,E,F,G>,H>` | Into7.`into7(Fn7<? super A,? super B,? super C,? super D,? super E,? super F,? super G,? extends H> fn)`
    `static <A,B,C,D,E,F,G,H,I> Fn1<Product8<A,B,C,D,E,F,G,H>,I>` | Into8.`into8(Fn8<? super A,? super B,? super C,? super D,? super E,? super F,? super G,? super H,? extends I> fn)`
    `static <A> Fn1<A,Iterable<A>>` | Iterate.`iterate(Fn1<? super A,? extends A> fn)`
    `static <A> Fn1<Iterable<A>,Iterable<Iterable<A>>>` | MagnetizeBy.`magnetizeBy(Fn2<? super A,? super A,? extends Boolean> predicate)`
    `static <A,B> Fn1<Iterable<A>,Iterable<B>>` | Map.`map(Fn1<? super A,? extends B> fn)`
    `static <A,B,C> Fn1<Iterable<A>,Tuple2<Iterable<B>,Iterable<C>>>` | Partition.`partition(Fn1<? super A,? extends CoProduct2<B,C,?>> function)`
    `static <A,FA extends Functor<A,?>> Fn1<FA,FA>` | Peek.`peek(Fn1<? super A,? extends IO<?>> effect)` 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> Fn1<Iterable<A>,Iterable<A>>` | PrependAll.`prependAll(A a)`
    `static <A> Fn1<Iterable<A>,Maybe<A>>` | ReduceLeft.`reduceLeft(Fn2<? super A,? super A,? extends A> fn)`
    `static <A> Fn1<Iterable<A>,Maybe<A>>` | ReduceRight.`reduceRight(Fn2<? super A,? super A,? extends A> fn)`
    `static <A> Fn1<A,Iterable<A>>` | Replicate.`replicate(Integer n)`
    `static <A,App extends Applicative<?,App>,AppIterable extends Applicative<Iterable<A>,App>> Fn1<Fn1<Iterable<A>,? extends AppIterable>,AppIterable>` | Sequence.`sequence(Iterable<? extends Applicative<A,App>> iterableApp)`
    `static <A,B,App extends Applicative<?,App>,AppMap extends Applicative<Map<A,B>,App>> Fn1<Fn1<Map<A,B>,? extends AppMap>,AppMap>` | Sequence.`sequence(Map<A,? extends Applicative<B,App>> mapApp)`
    `static <A,App extends Applicative<?,App>,Trav extends Traversable<?,Trav>,TravA extends Traversable<A,Trav>,AppTrav extends Applicative<TravA,App>> Fn1<Fn1<TravA,? extends AppTrav>,AppTrav>` | Sequence.`sequence(Traversable<? extends Applicative<A,App>,Trav> traversable)`
    `static <A> Fn1<Iterable<A>,Iterable<Iterable<A>>>` | Slide.`slide(Integer k)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | Snoc.`snoc(A a)`
    `static <A,B extends Comparable<B>> Fn1<Iterable<A>,List<A>>` | SortBy.`sortBy(Fn1<? super A,? extends B> fn)`
    `static <A> Fn1<Iterable<A>,List<A>>` | SortWith.`sortWith(Comparator<? super A> comparator)`
    `static <A> Fn1<Iterable<A>,Tuple2<Iterable<A>,Iterable<A>>>` | Span.`span(Fn1<? super A,? extends Boolean> predicate)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | Take.`take(int n)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | TakeWhile.`takeWhile(Fn1<? super A,? extends Boolean> predicate)`
    `static <A> Fn1<Iterable<? extends A>,A[]>` | ToArray.`toArray(Class<A[]> arrayType)`
    `static <A,C extends Collection<A>> Fn1<Iterable<A>,C>` | ToCollection.`toCollection(Fn0<C> cFn0)`
    `static <K,V,M extends Map<K,V>> Fn1<Iterable<? extends Map.Entry<K,V>>,M>` | ToMap.`toMap(Fn0<M> mFn0)`
    `static <A,B> Fn1<B,Tuple2<A,B>>` | Tupler2.`tupler(A a)`
    `static <A,B> Fn1<B,Iterable<A>>` | Unfoldr.`unfoldr(Fn1<? super B,Maybe<Tuple2<A,B>>> fn)`
    `static <A> Fn1<IO<A>,IO<A>>` | Until.`until(Fn1<? super A,? extends Boolean> pred)`
    `static <A,B> Fn1<Iterable<B>,Iterable<Tuple2<A,B>>>` | Zip.`zip(Iterable<A> as)`

    Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return types with arguments of type Fn1
    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,B,C> Fn1<Fn1<? super A,? extends C>,Fn1<A,Tuple2<B,C>>>` | Both.`both(Fn1<? super A,? extends B> f)`
    `static <A,B,C> Fn1<Fn1<? super A,? extends C>,Fn1<A,Tuple2<B,C>>>` | Both.`both(Fn1<? super A,? extends B> f)`
    `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,App extends Applicative<?,App>,AppIterable extends Applicative<Iterable<A>,App>> Fn1<Fn1<Iterable<A>,? extends AppIterable>,AppIterable>` | Sequence.`sequence(Iterable<? extends Applicative<A,App>> iterableApp)`
    `static <A,B,App extends Applicative<?,App>,AppMap extends Applicative<Map<A,B>,App>> Fn1<Fn1<Map<A,B>,? extends AppMap>,AppMap>` | Sequence.`sequence(Map<A,? extends Applicative<B,App>> mapApp)`
    `static <A,App extends Applicative<?,App>,Trav extends Traversable<?,Trav>,TravA extends Traversable<A,Trav>,AppTrav extends Applicative<TravA,App>> Fn1<Fn1<TravA,? extends AppTrav>,AppTrav>` | Sequence.`sequence(Traversable<? extends Applicative<A,App>,Trav> traversable)`

    Methods in com.jnape.palatable.lambda.functions.builtin.fn2 with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <A> Fn1<Iterable<A>,? extends Boolean>` | All.`all(Fn1<? super A,? extends Boolean> predicate)`
    `static <A> Boolean` | All.`all(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `static <A> Predicate<Iterable<A>>` | Any.`any(Fn1<? super A,? extends Boolean> predicate)`
    `static <A> Boolean` | Any.`any(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `static <A extends AutoCloseable,B> IO<B>` | AutoBracket.`autoBracket(IO<A> io, Fn1<? super A,? extends IO<B>> bodyIO)`
    `static <A,B,C> Fn1<Fn1<? super A,? extends C>,Fn1<A,Tuple2<B,C>>>` | Both.`both(Fn1<? super A,? extends B> f)`
    `static <A,B,C> Fn1<A,Tuple2<B,C>>` | Both.`both(Fn1<? super A,? extends B> f, Fn1<? super A,? extends C> g)`
    `static <A,B,C> Fn1<A,Tuple2<B,C>>` | Both.`both(Fn1<? super A,? extends B> f, Fn1<? super A,? extends C> g)`
    `static <A,B,C> Tuple2<B,C>` | Both.`both(Fn1<? super A,? extends B> f, Fn1<? super A,? extends C> g, A a)`
    `static <A,B,C> Tuple2<B,C>` | Both.`both(Fn1<? super A,? extends B> f, Fn1<? super A,? extends C> g, A a)`
    `Iterable<A>` | Iterate.`checkedApply(Fn1<? super A,? extends A> fn, A seed)`
    `Tuple2<B,C>` | Both.`checkedApply(Fn1<? super A,? extends B> f, Fn1<? super A,? extends C> g, A a)`
    `Tuple2<B,C>` | Both.`checkedApply(Fn1<? super A,? extends B> f, Fn1<? super A,? extends C> g, A a)`
    `Iterable<B>` | Map.`checkedApply(Fn1<? super A,? extends B> fn, Iterable<A> as)`
    `List<A>` | SortBy.`checkedApply(Fn1<? super A,? extends B> fn, Iterable<A> as)`
    `B` | Into1.`checkedApply(Fn1<? super A,? extends B> fn, SingletonHList<A> singletonHList)`
    `IO<A>` | Until.`checkedApply(Fn1<? super A,? extends Boolean> pred, IO<A> io)`
    `Boolean` | Any.`checkedApply(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `Boolean` | All.`checkedApply(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `Iterable<A>` | DropWhile.`checkedApply(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `Maybe<A>` | Find.`checkedApply(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `Iterable<A>` | TakeWhile.`checkedApply(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `Tuple2<Iterable<A>,Iterable<A>>` | Span.`checkedApply(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `Iterable<A>` | Filter.`checkedApply(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `Tuple2<Iterable<B>,Iterable<C>>` | Partition.`checkedApply(Fn1<? super A,? extends CoProduct2<B,C,?>> function, Iterable<A> as)`
    `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.
    `Iterable<A>` | Unfoldr.`checkedApply(Fn1<? super B,Maybe<Tuple2<A,B>>> fn, B b)`
    `Map<K,List<V>>` | GroupBy.`checkedApply(Fn1<? super V,? extends K> keyFn, Iterable<V> vs)`
    `IO<B>` | AutoBracket.`checkedApply(IO<A> io, Fn1<? super A,? extends IO<B>> bodyIO)`
    `AppTrav` | Sequence.`checkedApply(Traversable<? extends Applicative<A,App>,Trav> traversable, Fn1<TravA,? extends AppTrav> pure)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | DropWhile.`dropWhile(Fn1<? super A,? extends Boolean> predicate)`
    `static <A> Iterable<A>` | DropWhile.`dropWhile(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | Filter.`filter(Fn1<? super A,? extends Boolean> predicate)`
    `static <A> Iterable<A>` | Filter.`filter(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `static <A> Fn1<Iterable<A>,Maybe<A>>` | Find.`find(Fn1<? super A,? extends Boolean> predicate)`
    `static <A> Maybe<A>` | Find.`find(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `static <K,V> Fn1<Iterable<V>,Map<K,List<V>>>` | GroupBy.`groupBy(Fn1<? super V,? extends K> keyFn)`
    `static <K,V> Map<K,List<V>>` | GroupBy.`groupBy(Fn1<? super V,? extends K> keyFn, Iterable<V> vs)`
    `static <A,B> Fn1<SingletonHList<A>,B>` | Into1.`into1(Fn1<? super A,? extends B> fn)`
    `static <A,B> B` | Into1.`into1(Fn1<? super A,? extends B> fn, SingletonHList<A> singletonHList)`
    `static <A> Fn1<A,Iterable<A>>` | Iterate.`iterate(Fn1<? super A,? extends A> fn)`
    `static <A> Iterable<A>` | Iterate.`iterate(Fn1<? super A,? extends A> fn, A seed)`
    `static <A,B> Fn1<Iterable<A>,Iterable<B>>` | Map.`map(Fn1<? super A,? extends B> fn)`
    `static <A,B> Iterable<B>` | Map.`map(Fn1<? super A,? extends B> fn, Iterable<A> as)`
    `static <A,B,C> Fn1<Iterable<A>,Tuple2<Iterable<B>,Iterable<C>>>` | Partition.`partition(Fn1<? super A,? extends CoProduct2<B,C,?>> function)`
    `static <A,B,C> Tuple2<Iterable<B>,Iterable<C>>` | Partition.`partition(Fn1<? super A,? extends CoProduct2<B,C,?>> function, Iterable<A> as)`
    `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.
    `static <A,App extends Applicative<?,App>,AppIterable extends Applicative<Iterable<A>,App>> AppIterable` | Sequence.`sequence(Iterable<? extends Applicative<A,App>> iterableApp, Fn1<Iterable<A>,? extends AppIterable> pure)`
    `static <A,B,App extends Applicative<?,App>,AppMap extends Applicative<Map<A,B>,App>> AppMap` | Sequence.`sequence(Map<A,? extends Applicative<B,App>> mapApp, Fn1<Map<A,B>,? extends AppMap> pure)`
    `static <A,App extends Applicative<?,App>,Trav extends Traversable<?,Trav>,TravA extends Traversable<A,Trav>,AppTrav extends Applicative<TravA,App>> AppTrav` | Sequence.`sequence(Traversable<? extends Applicative<A,App>,Trav> traversable, Fn1<TravA,? extends AppTrav> pure)`
    `static <A,B extends Comparable<B>> Fn1<Iterable<A>,List<A>>` | SortBy.`sortBy(Fn1<? super A,? extends B> fn)`
    `static <A,B extends Comparable<B>> List<A>` | SortBy.`sortBy(Fn1<? super A,? extends B> fn, Iterable<A> as)`
    `static <A> Fn1<Iterable<A>,Tuple2<Iterable<A>,Iterable<A>>>` | Span.`span(Fn1<? super A,? extends Boolean> predicate)`
    `static <A> Tuple2<Iterable<A>,Iterable<A>>` | Span.`span(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | TakeWhile.`takeWhile(Fn1<? super A,? extends Boolean> predicate)`
    `static <A> Iterable<A>` | TakeWhile.`takeWhile(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `static <A,B> Fn1<B,Iterable<A>>` | Unfoldr.`unfoldr(Fn1<? super B,Maybe<Tuple2<A,B>>> fn)`
    `static <A,B> Iterable<A>` | Unfoldr.`unfoldr(Fn1<? super B,Maybe<Tuple2<A,B>>> fn, B b)`
    `static <A> Fn1<IO<A>,IO<A>>` | Until.`until(Fn1<? super A,? extends Boolean> pred)`
    `static <A> IO<A>` | Until.`until(Fn1<? super A,? extends Boolean> pred, IO<A> io)`

  - ### Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn3

    Classes in com.jnape.palatable.lambda.functions.builtin.fn3 that implement Fn1
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Between<A extends Comparable<A>>` Given two bounds and a value, return whether or not the value is greater than or equal to the lower bound and less than or equal to the upper bound.
    `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.
    `class` | `Clamp<A extends Comparable<A>>` Given two bounds and a value, "clamp" the value between the bounds via the following algorithm: - if the value is strictly less than the lower bound, return the lower bound - if the value is strictly greater than the upper bound, return the upper bound - otherwise, return the value
    `class` | `CmpEqBy<A,B extends Comparable<B>>` Given a mapping function from some type `A` to some `Comparable` type `B` and two values of type `A`, return `true` if the first value is strictly equal to the second value (according to `Comparable.compareTo(Object)` in terms of their mapped `B` results; otherwise, return false.
    `class` | `FoldLeft<A,B>` Given an `Iterable` of `A`s, a starting value `B`, and a ``Fn2`<B, A, B>`, iteratively accumulate over the `Iterable`, ultimately returning a final `B` value.
    `class` | `FoldRight<A,B>` Given an `Iterable` of `A`s, a starting `lazy` value `B`, and a ``Fn2`<A, `Lazy`<B>, `Lazy`<B>>`, iteratively accumulate over the `Iterable`, ultimately returning a final ``Lazy`<B>` value.
    `class` | `GTBy<A,B extends Comparable<B>>` Given a mapping function from some type `A` to some `Comparable` type `B` and two values of type `A`, return `true` if the second value is strictly greater than the first value in terms of their mapped `B` results; otherwise, return false.
    `class` | `GTEBy<A,B extends Comparable<B>>` Given a mapping function from some type `A` to some `Comparable` type `B` and two values of type `A`, return `true` if the second value is greater than or equal to the first value in terms of their mapped `B` results according to `Comparable.compareTo(Object)`; otherwise, return false.
    `class` | `LiftA2<A,B,C,App extends Applicative<?,App>,AppC extends Applicative<C,App>>` Lift into and apply an `Fn2` to two `Applicative` values, returning the result inside the same `Applicative` context.
    `class` | `LTBy<A,B extends Comparable<B>>` Given a mapping function from some type `A` to some `Comparable` type `B` and two values of type `A`, return `true` if the second value is strictly less than the first value in terms of their mapped `B` results; otherwise, return false.
    `class` | `LTEBy<A,B extends Comparable<B>>` Given a mapping function from some type `A` to some `Comparable` type `B` and two values of type `A`, return `true` if the second value is less than or equal to the first value in terms of their mapped `B` results according to `Comparable.compareTo(Object)`; otherwise, return false.
    `class` | `ScanLeft<A,B>` Given an `Iterable` of `A`s, a starting value `B`, and a ``Fn2`<B, A, B>`, iteratively accumulate over the `Iterable`, collecting each function application result, finally returning an `Iterable` of all the results.
    `class` | `Times<A>` Given some number of times `n` to invoke a function `A -> A`, and given an input `A`, iteratively apply the function to the input, and then to the result of the invocation, a total of `n` times, returning the result.
    `class` | `ZipWith<A,B,C>` Zip together two `Iterable`s by applying a zipping function to the successive elements of each `Iterable` until one of them runs out of elements.

    Methods in com.jnape.palatable.lambda.functions.builtin.fn3 that return Fn1
    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 extends Comparable<A>> Fn1<A,A>` | Clamp.`clamp(A lower, A upper)`
    `static <A,B> Fn1<Iterable<A>,B>` | FoldLeft.`foldLeft(Fn2<? super B,? super A,? extends B> fn, B acc)`
    `static <A,B> Fn1<Iterable<A>,Lazy<B>>` | FoldRight.`foldRight(Fn2<? super A,? super Lazy<B>,? extends Lazy<B>> fn, Lazy<B> acc)`
    `static <A,B,C,App extends Applicative<?,App>,AppC extends Applicative<C,App>> Fn1<Applicative<B,App>,AppC>` | LiftA2.`liftA2(Fn2<? super A,? super B,? extends C> fn, Applicative<A,App> appA)`
    `static <A,B> Fn1<Iterable<A>,Iterable<B>>` | ScanLeft.`scanLeft(Fn2<? super B,? super A,? extends B> fn, B b)`
    `static <A> Fn1<A,A>` | Times.`times(Integer n, Fn1<? super A,? extends A> fn)`
    `static <A,B,C> Fn1<Iterable<B>,Iterable<C>>` | ZipWith.`zipWith(Fn2<? super A,? super B,? extends C> zipper, Iterable<A> as)`

    Methods in com.jnape.palatable.lambda.functions.builtin.fn3 that return types with arguments of type Fn1
    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> Fn1<Fn1<? super A,? extends IO<B>>,IO<B>>` | Bracket.`bracket(IO<A> io, Fn1<? super A,? extends IO<?>> cleanupIO)`
    `static <A> Fn2<Fn1<? super A,? extends A>,A,A>` | Times.`times(Integer n)`

    Methods in com.jnape.palatable.lambda.functions.builtin.fn3 with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `BiPredicate<A,A>` | LTBy.`apply(Fn1<? super A,? extends B> compareFn)`
    `BiPredicate<A,A>` | CmpEqBy.`apply(Fn1<? super A,? extends B> compareFn)`
    `BiPredicate<A,A>` | GTBy.`apply(Fn1<? super A,? extends B> compareFn)`
    `BiPredicate<A,A>` | LTEBy.`apply(Fn1<? super A,? extends B> compareFn)`
    `BiPredicate<A,A>` | GTEBy.`apply(Fn1<? super A,? extends B> compareFn)`
    `Predicate<A>` | LTBy.`apply(Fn1<? super A,? extends B> compareFn, A y)`
    `Predicate<A>` | CmpEqBy.`apply(Fn1<? super A,? extends B> compareFn, A x)`
    `Predicate<A>` | GTBy.`apply(Fn1<? super A,? extends B> compareFn, A x)`
    `Predicate<A>` | LTEBy.`apply(Fn1<? super A,? extends B> compareFn, A y)`
    `Predicate<A>` | GTEBy.`apply(Fn1<? super A,? extends B> compareFn, A y)`
    `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)`
    `Boolean` | LTBy.`checkedApply(Fn1<? super A,? extends B> compareFn, A y, A x)`
    `Boolean` | CmpEqBy.`checkedApply(Fn1<? super A,? extends B> compareFn, A x, A y)`
    `Boolean` | GTBy.`checkedApply(Fn1<? super A,? extends B> compareFn, A y, A x)`
    `Boolean` | LTEBy.`checkedApply(Fn1<? super A,? extends B> compareFn, A y, A x)`
    `Boolean` | GTEBy.`checkedApply(Fn1<? super A,? extends B> compareFn, A y, A x)`
    `A` | Times.`checkedApply(Integer n, Fn1<? super A,? extends A> fn, A a)`
    `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)`
    `static <A,B extends Comparable<B>> BiPredicate<A,A>` | CmpEqBy.`cmpEqBy(Fn1<? super A,? extends B> compareFn)`
    `static <A,B extends Comparable<B>> Predicate<A>` | CmpEqBy.`cmpEqBy(Fn1<? super A,? extends B> compareFn, A x)`
    `static <A,B extends Comparable<B>> Boolean` | CmpEqBy.`cmpEqBy(Fn1<? super A,? extends B> compareFn, A x, A y)`
    `static <A,B extends Comparable<B>> BiPredicate<A,A>` | GTBy.`gtBy(Fn1<? super A,? extends B> fn)`
    `static <A,B extends Comparable<B>> Predicate<A>` | GTBy.`gtBy(Fn1<? super A,? extends B> fn, A y)`
    `static <A,B extends Comparable<B>> Boolean` | GTBy.`gtBy(Fn1<? super A,? extends B> fn, A y, A x)`
    `static <A,B extends Comparable<B>> BiPredicate<A,A>` | GTEBy.`gteBy(Fn1<? super A,? extends B> fn)`
    `static <A,B extends Comparable<B>> Predicate<A>` | GTEBy.`gteBy(Fn1<? super A,? extends B> fn, A y)`
    `static <A,B extends Comparable<B>> Boolean` | GTEBy.`gteBy(Fn1<? super A,? extends B> fn, A y, A x)`
    `static <A,B extends Comparable<B>> BiPredicate<A,A>` | LTBy.`ltBy(Fn1<? super A,? extends B> fn)`
    `static <A,B extends Comparable<B>> Predicate<A>` | LTBy.`ltBy(Fn1<? super A,? extends B> fn, A y)`
    `static <A,B extends Comparable<B>> Boolean` | LTBy.`ltBy(Fn1<? super A,? extends B> fn, A y, A x)`
    `static <A,B extends Comparable<B>> BiPredicate<A,A>` | LTEBy.`lteBy(Fn1<? super A,? extends B> fn)`
    `static <A,B extends Comparable<B>> Predicate<A>` | LTEBy.`lteBy(Fn1<? super A,? extends B> fn, A y)`
    `static <A,B extends Comparable<B>> Boolean` | LTEBy.`lteBy(Fn1<? super A,? extends B> fn, A y, A x)`
    `static <A> Fn1<A,A>` | Times.`times(Integer n, Fn1<? super A,? extends A> fn)`
    `static <A> A` | Times.`times(Integer n, Fn1<? super A,? extends A> fn, A a)`

  - ### Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn4

    Classes in com.jnape.palatable.lambda.functions.builtin.fn4 that implement Fn1
    Modifier and Type | Class and Description
    --- | ---
    `class` | `IfThenElse<A,B>`
    `class` | `LiftA3<A,B,C,D,App extends Applicative<?,App>,AppD extends Applicative<D,App>>` Lift into and apply an `Fn3` to three `Applicative` values, returning the result inside the same `Applicative` context.
    `class` | `RateLimit<A>` Given an `Fn0` of `Instants` (presumably backed by a clock), a `limit`, a `Duration`, and an `Iterable` `as`, return an `Iterable` that iterates `as` according to the threshold specified by the limit per duration, using the `Fn0` to advance time.

    Methods in com.jnape.palatable.lambda.functions.builtin.fn4 that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B> Fn1<A,B>` | IfThenElse.`ifThenElse(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase, Fn1<? super A,? extends B> elseCase)`
    `static <A,B,C,D,App extends Applicative<?,App>,AppD extends Applicative<D,App>> Fn1<Applicative<C,App>,AppD>` | LiftA3.`liftA3(Fn3<A,B,C,D> fn, Applicative<A,App> appA, Applicative<B,App> appB)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | RateLimit.`rateLimit(Fn0<Instant> instantFn0, Long limit, Duration duration)`

    Methods in com.jnape.palatable.lambda.functions.builtin.fn4 that return types with arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B> Fn3<Fn1<? super A,? extends B>,Fn1<? super A,? extends B>,A,B>` | IfThenElse.`ifThenElse(Fn1<? super A,? extends Boolean> predicate)`
    `static <A,B> Fn3<Fn1<? super A,? extends B>,Fn1<? super A,? extends B>,A,B>` | IfThenElse.`ifThenElse(Fn1<? super A,? extends Boolean> predicate)`
    `static <A,B> Fn2<Fn1<? super A,? extends B>,A,B>` | IfThenElse.`ifThenElse(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase)`

    Methods in com.jnape.palatable.lambda.functions.builtin.fn4 with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `B` | IfThenElse.`checkedApply(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase, Fn1<? super A,? extends B> elseCase, A a)`
    `B` | IfThenElse.`checkedApply(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase, Fn1<? super A,? extends B> elseCase, A a)`
    `B` | IfThenElse.`checkedApply(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase, Fn1<? super A,? extends B> elseCase, A a)`
    `static <A,B> Fn3<Fn1<? super A,? extends B>,Fn1<? super A,? extends B>,A,B>` | IfThenElse.`ifThenElse(Fn1<? super A,? extends Boolean> predicate)`
    `static <A,B> Fn2<Fn1<? super A,? extends B>,A,B>` | IfThenElse.`ifThenElse(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase)`
    `static <A,B> Fn2<Fn1<? super A,? extends B>,A,B>` | IfThenElse.`ifThenElse(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase)`
    `static <A,B> Fn1<A,B>` | IfThenElse.`ifThenElse(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase, Fn1<? super A,? extends B> elseCase)`
    `static <A,B> Fn1<A,B>` | IfThenElse.`ifThenElse(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase, Fn1<? super A,? extends B> elseCase)`
    `static <A,B> Fn1<A,B>` | IfThenElse.`ifThenElse(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase, Fn1<? super A,? extends B> elseCase)`
    `static <A,B> B` | IfThenElse.`ifThenElse(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase, Fn1<? super A,? extends B> elseCase, A a)`
    `static <A,B> B` | IfThenElse.`ifThenElse(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase, Fn1<? super A,? extends B> elseCase, A a)`
    `static <A,B> B` | IfThenElse.`ifThenElse(Fn1<? super A,? extends Boolean> predicate, Fn1<? super A,? extends B> thenCase, Fn1<? super A,? extends B> elseCase, A a)`

  - ### Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn5

    Classes in com.jnape.palatable.lambda.functions.builtin.fn5 that implement Fn1
    Modifier and Type | Class and Description
    --- | ---
    `class` | `LiftA4<A,B,C,D,E,App extends Applicative<?,App>,AppE extends Applicative<E,App>>` Lift into and apply an `Fn4` to four `Applicative` values, returning the result inside the same `Applicative` context.

    Methods in com.jnape.palatable.lambda.functions.builtin.fn5 that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B,C,D,E,App extends Applicative<?,App>,AppE extends Applicative<E,App>> Fn1<Applicative<D,App>,AppE>` | LiftA4.`liftA4(Fn4<A,B,C,D,E> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC)`

  - ### Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn6

    Classes in com.jnape.palatable.lambda.functions.builtin.fn6 that implement Fn1
    Modifier and Type | Class and Description
    --- | ---
    `class` | `LiftA5<A,B,C,D,E,F,App extends Applicative<?,App>,AppF extends Applicative<F,App>>` Lift into and apply an `Fn5` to five `Applicative` values, returning the result inside the same `Applicative` context.

    Methods in com.jnape.palatable.lambda.functions.builtin.fn6 that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B,C,D,E,F,App extends Applicative<?,App>,AppF extends Applicative<F,App>> Fn1<Applicative<E,App>,AppF>` | LiftA5.`liftA5(Fn5<A,B,C,D,E,F> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC, Applicative<D,App> appD)`

  - ### Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn7

    Classes in com.jnape.palatable.lambda.functions.builtin.fn7 that implement Fn1
    Modifier and Type | Class and Description
    --- | ---
    `class` | `LiftA6<A,B,C,D,E,F,G,App extends Applicative<?,App>,AppG extends Applicative<G,App>>` Lift into and apply an `Fn6` to six `Applicative` values, returning the result inside the same `Applicative` context.

    Methods in com.jnape.palatable.lambda.functions.builtin.fn7 that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B,C,D,E,F,G,App extends Applicative<?,App>,AppG extends Applicative<G,App>> Fn1<Applicative<F,App>,AppG>` | LiftA6.`liftA6(Fn6<A,B,C,D,E,F,G> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC, Applicative<D,App> appD, Applicative<E,App> appE)`

  - ### Uses of Fn1 in com.jnape.palatable.lambda.functions.builtin.fn8

    Classes in com.jnape.palatable.lambda.functions.builtin.fn8 that implement Fn1
    Modifier and Type | Class and Description
    --- | ---
    `class` | `LiftA7<A,B,C,D,E,F,G,H,App extends Applicative<?,App>,AppH extends Applicative<H,App>>` Lift into and apply an `Fn7` to seven `Applicative` values, returning the result inside the same `Applicative` context.

    Methods in com.jnape.palatable.lambda.functions.builtin.fn8 that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B,C,D,E,F,G,H,App extends Applicative<?,App>,AppH extends Applicative<H,App>> Fn1<Applicative<G,App>,AppH>` | LiftA7.`liftA7(Fn7<A,B,C,D,E,F,G,H> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC, Applicative<D,App> appD, Applicative<E,App> appE, Applicative<F,App> appF)`

  - ### Uses of Fn1 in com.jnape.palatable.lambda.functions.recursion

    Classes in com.jnape.palatable.lambda.functions.recursion that implement Fn1
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Trampoline<A,B>` Given an ``Fn1`<A, `CoProduct2`<A, B, ?>>` (analogous to "recurse" and "return" tail position instructions, respectively), produce a ``Fn1`<A, B>` that unrolls the original function by iteratively passing each result that matches the input (`A`) back to the original function, and then terminating on and returning the first output (`B`).

    Methods in com.jnape.palatable.lambda.functions.recursion that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B> Fn1<A,B>` | Trampoline.`trampoline(Fn1<? super A,? extends RecursiveResult<A,B>> fn)`

    Methods in com.jnape.palatable.lambda.functions.recursion with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<C,D> RecursiveResult<C,D>` | RecursiveResult.`biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually map covariantly over both the left and right parameters.
    `<C,D> RecursiveResult<C,D>` | RecursiveResult.`biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually map covariantly over both the left and right parameters.
    `<C> RecursiveResult<C,B>` | RecursiveResult.`biMapL(Fn1<? super A,? extends C> fn)` Covariantly map over the left parameter.
    `<C> RecursiveResult<A,C>` | RecursiveResult.`biMapR(Fn1<? super B,? extends C> fn)` Covariantly map over the right parameter.
    `B` | Trampoline.`checkedApply(Fn1<? super A,? extends RecursiveResult<A,B>> fn, A a)`
    `<C> RecursiveResult<A,C>` | RecursiveResult.`flatMap(Fn1<? super B,? extends Monad<C,RecursiveResult<A,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<C> RecursiveResult<A,C>` | RecursiveResult.`fmap(Fn1<? super B,? extends C> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `static <A,B> Fn1<A,B>` | Trampoline.`trampoline(Fn1<? super A,? extends RecursiveResult<A,B>> fn)`
    `static <A,B> B` | Trampoline.`trampoline(Fn1<? super A,? extends RecursiveResult<A,B>> fn, A a)`
    `<C> RecursiveResult<A,C>` | RecursiveResult.`trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,RecursiveResult<A,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<C,App extends Applicative<?,App>,TravB extends Traversable<C,RecursiveResult<A,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | RecursiveResult.`traverse(Fn1<? super B,? extends Applicative<C,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<C,App extends Applicative<?,App>,TravB extends Traversable<C,RecursiveResult<A,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | RecursiveResult.`traverse(Fn1<? super B,? extends Applicative<C,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.

    Method parameters in com.jnape.palatable.lambda.functions.recursion with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<C> RecursiveResult<A,C>` | RecursiveResult.`zip(Applicative<Fn1<? super B,? extends C>,RecursiveResult<A,?>> 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 Fn1 in com.jnape.palatable.lambda.functions.specialized

    Subinterfaces of Fn1 in com.jnape.palatable.lambda.functions.specialized
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BiMonoidFactory<A,B,C>`
    `interface` | `BiPredicate<A,B>` A specialized `Fn2` that returns a Boolean when fully applied, or a `Predicate` when partially applied.
    `interface` | `BiSemigroupFactory<A,B,C>`
    `interface` | `Kleisli<A,B,M extends Monad<?,M>,MB extends Monad<B,M>>` The Kleisli arrow of a `Monad`, manifest as simply an ``Fn1`<A, MB>`.
    `interface` | `MonoidFactory<A,B>`
    `interface` | `Predicate<A>` A specialized `Fn1` that returns a `Boolean`.
    `interface` | `SemigroupFactory<A,B>`

    Methods in com.jnape.palatable.lambda.functions.specialized with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default <Z> Fn2<Z,B,Boolean>` | BiPredicate.`contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `default <Z> Predicate<Z>` | Predicate.`contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `default <Z> Kleisli<Z,B,M,MB>` | Kleisli.`contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `default <Z> BiPredicate<Z,B>` | BiPredicate.`diMapL(Fn1<? super Z,? extends A> fn)` Contravariantly map over the argument to this function, producing a function that takes the new argument type, and produces the same result.
    `default <Z> Predicate<Z>` | Predicate.`diMapL(Fn1<? super Z,? extends A> fn)` Contravariantly map over the argument to this function, producing a function that takes the new argument type, and produces the same result.
    `default <Z> Kleisli<Z,B,M,MB>` | Kleisli.`diMapL(Fn1<? super Z,? extends A> fn)` Contravariantly map over the argument to this function, producing a function that takes the new argument type, and produces the same result.
    `static <A,B,M extends Monad<?,M>,MB extends Monad<B,M>> Kleisli<A,B,M,MB>` | Kleisli.`kleisli(Fn1<? super A,? extends MB> fn)` Adapt a compatible function into a `Kleisli` arrow.
    `static <A> Predicate<A>` | Predicate.`predicate(Fn1<? super A,? extends Boolean> predicate)` Static factory method to create a predicate from an `Fn1`.

    Method parameters in com.jnape.palatable.lambda.functions.specialized with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default <C> Predicate<A>` | Predicate.`discardR(Applicative<C,Fn1<A,?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `default <C> Kleisli<A,B,M,MB>` | Kleisli.`discardR(Applicative<C,Fn1<A,?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `default <D> BiPredicate<A,B>` | BiPredicate.`discardR(Applicative<D,Fn1<A,?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.

  - ### Uses of Fn1 in com.jnape.palatable.lambda.functor

    Methods in com.jnape.palatable.lambda.functor with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<C,D> Bifunctor<C,D,BF>` | Bifunctor.`biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually map covariantly over both the left and right parameters.
    `<C,D> Bifunctor<C,D,BF>` | Bifunctor.`biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually map covariantly over both the left and right parameters.
    `<C extends ContraA,D extends ContraB> BoundedBifunctor<C,D,ContraA,ContraB,BF>` | BoundedBifunctor.`biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually covariantly map both the left and right parameters into values that are covariant to `ContraA` and `ContraB`, respectively.
    `<C extends ContraA,D extends ContraB> BoundedBifunctor<C,D,ContraA,ContraB,BF>` | BoundedBifunctor.`biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually covariantly map both the left and right parameters into values that are covariant to `ContraA` and `ContraB`, respectively.
    `default <C> Bifunctor<C,B,BF>` | Bifunctor.`biMapL(Fn1<? super A,? extends C> fn)` Covariantly map over the left parameter.
    `default <C extends ContraA> BoundedBifunctor<C,B,ContraA,ContraB,BF>` | BoundedBifunctor.`biMapL(Fn1<? super A,? extends C> fn)` Covariantly map the left parameter into a value that is covariant to `ContraA`.
    `default <C> Bifunctor<A,C,BF>` | Bifunctor.`biMapR(Fn1<? super B,? extends C> fn)` Covariantly map over the right parameter.
    `default <C extends ContraB> BoundedBifunctor<A,C,ContraA,ContraB,BF>` | BoundedBifunctor.`biMapR(Fn1<? super B,? extends C> fn)` Covariantly map the right parameter into a value that is covariant to `ContraB`.
    `<B> Contravariant<B,C>` | Contravariant.`contraMap(Fn1<? super B,? extends A> fn)` Contravariantly map `A <- B`.
    `default <Z> Cocartesian<Z,B,P>` | Cocartesian.`contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `default <Z> Profunctor<Z,B,PF>` | Profunctor.`contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `default <Z> Cartesian<Z,B,P>` | Cartesian.`contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `<Z,C> Cocartesian<Z,C,P>` | Cocartesian.`diMap(Fn1<? super Z,? extends A> lFn, Fn1<? super B,? extends C> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<Z,C> Cocartesian<Z,C,P>` | Cocartesian.`diMap(Fn1<? super Z,? extends A> lFn, Fn1<? super B,? extends C> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<Z,C> Profunctor<Z,C,PF>` | Profunctor.`diMap(Fn1<? super Z,? extends A> lFn, Fn1<? super B,? extends C> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<Z,C> Profunctor<Z,C,PF>` | Profunctor.`diMap(Fn1<? super Z,? extends A> lFn, Fn1<? super B,? extends C> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<Z,C> Cartesian<Z,C,P>` | Cartesian.`diMap(Fn1<? super Z,? extends A> lFn, Fn1<? super B,? extends C> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<Z,C> Cartesian<Z,C,P>` | Cartesian.`diMap(Fn1<? super Z,? extends A> lFn, Fn1<? super B,? extends C> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `default <Z> Cocartesian<Z,B,P>` | Cocartesian.`diMapL(Fn1<? super Z,? extends A> fn)` Contravariantly map over the left parameter.
    `default <Z> Profunctor<Z,B,PF>` | Profunctor.`diMapL(Fn1<? super Z,? extends A> fn)` Contravariantly map over the left parameter.
    `default <Z> Cartesian<Z,B,P>` | Cartesian.`diMapL(Fn1<? super Z,? extends A> fn)` Contravariantly map over the left parameter.
    `default <C> Cocartesian<A,C,P>` | Cocartesian.`diMapR(Fn1<? super B,? extends C> fn)` Covariantly map over the right parameter.
    `default <C> Profunctor<A,C,PF>` | Profunctor.`diMapR(Fn1<? super B,? extends C> fn)` Covariantly map over the right parameter.
    `default <C> Cartesian<A,C,P>` | Cartesian.`diMapR(Fn1<? super B,? extends C> fn)` Covariantly map over the right parameter.
    `default <B> Applicative<B,App>` | Applicative.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> Functor<B,F>` | Functor.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.

    Method parameters in com.jnape.palatable.lambda.functor with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default <B> Lazy<? extends Applicative<B,App>>` | Applicative.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,App>> 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> Applicative<B,App>` | Applicative.`zip(Applicative<Fn1<? super A,? extends B>,App> 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 Fn1 in com.jnape.palatable.lambda.functor.builtin

    Methods in com.jnape.palatable.lambda.functor.builtin that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `Fn1<? super B,? extends T>` | Market.`bt()` Extract the mapping `B -> T`.
    `Fn1<? super B,? extends T>` | Exchange.`bt()` Extract the mapping `B -> T`.
    `Fn1<? super S,? extends A>` | Exchange.`sa()` Extract the mapping `S -> A`.
    `Fn1<? super S,? extends Either<T,A>>` | Market.`sta()` Extract the mapping `S -> `Either`<T, A>`.

    Methods in com.jnape.palatable.lambda.functor.builtin with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<C,D> Const<C,D>` | Const.`biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually map covariantly over both the left and right parameters.
    `<C,D> Const<C,D>` | Const.`biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually map covariantly over both the left and right parameters.
    `<Z> Const<Z,B>` | Const.`biMapL(Fn1<? super A,? extends Z> fn)` Covariantly map over the left parameter.
    `<C> Const<A,C>` | Const.`biMapR(Fn1<? super B,? extends C> fn)` Covariantly map over the right parameter.
    `State<S,A>` | State.`censor(Fn1<? super S,? extends S> fn)` Update the accumulated state.
    `Writer<W,A>` | Writer.`censor(Fn1<? super W,? extends W> fn)` Update the accumulated state.
    `<R> Market<A,B,R,T>` | Market.`contraMap(Fn1<? super R,? extends S> fn)` Contravariantly map `A <- B`.
    `<Z> Tagged<Z,B>` | Tagged.`contraMap(Fn1<? super Z,? extends S> fn)` Contravariantly map `A <- B`.
    `<Z> Exchange<A,B,Z,T>` | Exchange.`contraMap(Fn1<? super Z,? extends S> fn)` Contravariantly map `A <- B`.
    `<R,U> Market<A,B,R,U>` | Market.`diMap(Fn1<? super R,? extends S> lFn, Fn1<? super T,? extends U> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<R,U> Market<A,B,R,U>` | Market.`diMap(Fn1<? super R,? extends S> lFn, Fn1<? super T,? extends U> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<Z,C> Tagged<Z,C>` | Tagged.`diMap(Fn1<? super Z,? extends S> lFn, Fn1<? super B,? extends C> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<Z,C> Tagged<Z,C>` | Tagged.`diMap(Fn1<? super Z,? extends S> lFn, Fn1<? super B,? extends C> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<Z,C> Exchange<A,B,Z,C>` | Exchange.`diMap(Fn1<? super Z,? extends S> lFn, Fn1<? super T,? extends C> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<Z,C> Exchange<A,B,Z,C>` | Exchange.`diMap(Fn1<? super Z,? extends S> lFn, Fn1<? super T,? extends C> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<R> Market<A,B,R,T>` | Market.`diMapL(Fn1<? super R,? extends S> fn)` Contravariantly map over the left parameter.
    `<Z> Tagged<Z,B>` | Tagged.`diMapL(Fn1<? super Z,? extends S> fn)` Contravariantly map over the left parameter.
    `<Z> Exchange<A,B,Z,T>` | Exchange.`diMapL(Fn1<? super Z,? extends S> fn)` Contravariantly map over the left parameter.
    `<C> Tagged<S,C>` | Tagged.`diMapR(Fn1<? super B,? extends C> fn)` Covariantly map over the right parameter.
    `<C> Exchange<A,B,S,C>` | Exchange.`diMapR(Fn1<? super T,? extends C> fn)` Covariantly map over the right parameter.
    `<U> Market<A,B,S,U>` | Market.`diMapR(Fn1<? super T,? extends U> fn)` Covariantly map over the right parameter.
    `<B> Identity<B>` | Identity.`flatMap(Fn1<? super A,? extends Monad<B,Identity<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> Lazy<B>` | Lazy.`flatMap(Fn1<? super A,? extends Monad<B,Lazy<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> State<S,B>` | State.`flatMap(Fn1<? super A,? extends Monad<B,State<S,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> Writer<W,B>` | Writer.`flatMap(Fn1<? super A,? extends Monad<B,Writer<W,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<C> Const<A,C>` | Const.`flatMap(Fn1<? super B,? extends Monad<C,Const<A,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<C> Tagged<S,C>` | Tagged.`flatMap(Fn1<? super B,? extends Monad<C,Tagged<S,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<U> Market<A,B,S,U>` | Market.`flatMap(Fn1<? super T,? extends Monad<U,Market<A,B,S,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> Writer<W,B>` | Writer.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> Compose<F,G,B>` | Compose.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> Identity<B>` | Identity.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> Lazy<B>` | Lazy.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> State<S,B>` | State.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<C> Tagged<S,C>` | Tagged.`fmap(Fn1<? super B,? extends C> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<C> Const<A,C>` | Const.`fmap(Fn1<? super B,? extends C> fn)` Map over the right parameter.
    `<U> Market<A,B,S,U>` | Market.`fmap(Fn1<? super T,? extends U> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `static <S,A> State<S,A>` | State.`gets(Fn1<? super S,? extends A> fn)` Create a `State` that maps its initial state into its result, but leaves the initial state unchanged.
    `<B> State<S,Tuple2<A,B>>` | State.`listens(Fn1<? super S,? extends B> fn)` Map the accumulation into a value and pair it with the current output.
    `<B> Writer<W,Tuple2<A,B>>` | Writer.`listens(Fn1<? super W,? extends B> fn)` Map the accumulation into a value and pair it with the current output.
    `State<S,A>` | State.`local(Fn1<? super S,? extends S> fn)` Modify this `MonadReader's` environment after reading it but before running the effect.
    `<B> State<S,B>` | State.`mapState(Fn1<? super Tuple2<A,S>,? extends Tuple2<B,S>> fn)` Map both the result and the final state to a new result and final state.
    `static <S> State<S,Unit>` | State.`modify(Fn1<? super S,? extends S> fn)` Create a `State` that maps its initial state into its final state, returning a `Unit` result type.
    `static <S,A> State<S,A>` | State.`state(Fn1<? super S,? extends Tuple2<A,S>> stateFn)` Create a `State` from `stateFn`, a function that maps an initial state into a result and a final state.
    `<B> Identity<B>` | Identity.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Identity<?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> Lazy<B>` | Lazy.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Lazy<?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> State<S,B>` | State.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,State<S,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> Writer<W,B>` | Writer.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Writer<W,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<C> Const<A,C>` | Const.`trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Const<A,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<C> Tagged<S,C>` | Tagged.`trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Tagged<S,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<U> Market<A,B,S,U>` | Market.`trampolineM(Fn1<? super T,? extends MonadRec<RecursiveResult<T,U>,Market<A,B,S,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,Identity<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Identity.`traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,Identity<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Identity.`traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,Lazy<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Lazy.`traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,Lazy<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Lazy.`traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<C,App extends Applicative<?,App>,TravB extends Traversable<C,Const<A,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Const.`traverse(Fn1<? super B,? extends Applicative<C,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<C,App extends Applicative<?,App>,TravB extends Traversable<C,Const<A,?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | Const.`traverse(Fn1<? super B,? extends Applicative<C,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<C,App extends Applicative<?,App>,TravC extends Traversable<C,Tagged<S,?>>,AppTrav extends Applicative<TravC,App>> AppTrav` | Tagged.`traverse(Fn1<? super B,? extends Applicative<C,App>> fn, Fn1<? super TravC,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<C,App extends Applicative<?,App>,TravC extends Traversable<C,Tagged<S,?>>,AppTrav extends Applicative<TravC,App>> AppTrav` | Tagged.`traverse(Fn1<? super B,? extends Applicative<C,App>> fn, Fn1<? super TravC,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `State<S,A>` | State.`withState(Fn1<? super S,? extends S> fn)` Map the final state to a new final state using the provided function.

    Method parameters in com.jnape.palatable.lambda.functor.builtin with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<Compose<F,G,B>>` | Compose.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Compose<F,G,?>>> 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> Lazy<Identity<B>>` | Identity.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Identity<?>>> 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> Lazy<State<S,B>>` | State.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,State<S,?>>> 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> Lazy<Writer<W,B>>` | Writer.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,Writer<W,?>>> 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.
    `<C> Lazy<Const<A,C>>` | Const.`lazyZip(Lazy<? extends Applicative<Fn1<? super B,? extends C>,Const<A,?>>> 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> Compose<F,G,B>` | Compose.`zip(Applicative<Fn1<? super A,? extends B>,Compose<F,G,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<B> Identity<B>` | Identity.`zip(Applicative<Fn1<? super A,? extends B>,Identity<?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<B> Lazy<B>` | Lazy.`zip(Applicative<Fn1<? super A,? extends B>,Lazy<?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<B> State<S,B>` | State.`zip(Applicative<Fn1<? super A,? extends B>,State<S,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<B> Writer<W,B>` | Writer.`zip(Applicative<Fn1<? super A,? extends B>,Writer<W,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<C> Const<A,C>` | Const.`zip(Applicative<Fn1<? super B,? extends C>,Const<A,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<C> Tagged<S,C>` | Tagged.`zip(Applicative<Fn1<? super B,? extends C>,Tagged<S,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<U> Market<A,B,S,U>` | Market.`zip(Applicative<Fn1<? super T,? extends U>,Market<A,B,S,?>> 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.functor.builtin with parameters of type Fn1
    Constructor and Description
    `Exchange(Fn1<? super S,? extends A> sa, Fn1<? super B,? extends T> bt)`
    `Exchange(Fn1<? super S,? extends A> sa, Fn1<? super B,? extends T> bt)`
    `Market(Fn1<? super B,? extends T> bt, Fn1<? super S,? extends Either<T,A>> sta)`
    `Market(Fn1<? super B,? extends T> bt, Fn1<? super S,? extends Either<T,A>> sta)`

  - ### Uses of Fn1 in com.jnape.palatable.lambda.internal.iteration

    Constructors in com.jnape.palatable.lambda.internal.iteration with parameters of type Fn1
    Constructor and Description
    `FilteringIterable(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `FilteringIterator(Fn1<? super A,? extends Boolean> predicate, Iterator<A> iterator)`
    `MappingIterable(Fn1<? super A,? extends B> fn, Iterable<A> as)`
    `MappingIterator(Fn1<? super A,? extends B> function, Iterator<A> iterator)`
    `PredicatedDroppingIterable(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `PredicatedDroppingIterator(Fn1<? super A,? extends Boolean> predicate, Iterator<A> asIterator)`
    `PredicatedTakingIterable(Fn1<? super A,? extends Boolean> predicate, Iterable<A> as)`
    `PredicatedTakingIterator(Fn1<? super A,? extends Boolean> predicate, Iterator<A> asIterator)`
    `TrampoliningIterator(Fn1<? super A,? extends Iterable<RecursiveResult<A,B>>> fn, A a)`
    `UnfoldingIterator(Fn1<? super B,Maybe<Tuple2<A,B>>> function, B seed)`

  - ### Uses of Fn1 in com.jnape.palatable.lambda.io

    Methods in com.jnape.palatable.lambda.io with parameters of type Fn1
    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.
    `IO<A>` | IO.`exceptionally(Fn1<? super Throwable,? extends A> recoveryFn)` Deprecated. in favor of canonical `IO.catchError(Fn1)`
    `<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.
    `<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.

    Method parameters in com.jnape.palatable.lambda.io with type arguments of type Fn1
    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.
    `<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 Fn1 in com.jnape.palatable.lambda.monad

    Methods in com.jnape.palatable.lambda.monad with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `MonadError<E,A,M>` | MonadError.`catchError(Fn1<? super E,? extends Monad<A,M>> recoveryFn)` Catch any `thrown` errors inside the `Monad` and resume normal operations.
    `MonadWriter<W,A,MW>` | MonadWriter.`censor(Fn1<? super W,? extends W> fn)` Update the accumulated state.
    `<B> MonadError<E,B,M>` | MonadError.`flatMap(Fn1<? super A,? extends Monad<B,M>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> Monad<B,M>` | Monad.`flatMap(Fn1<? super A,? extends Monad<B,M>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> MonadRec<B,M>` | MonadRec.`flatMap(Fn1<? super A,? extends Monad<B,M>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> MonadReader<R,B,MR>` | MonadReader.`flatMap(Fn1<? super A,? extends Monad<B,MR>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> MonadWriter<W,B,MW>` | MonadWriter.`flatMap(Fn1<? super A,? extends Monad<B,MW>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> SafeT<M,B>` | SafeT.`flatMap(Fn1<? super A,? extends Monad<B,SafeT<M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `default <B> MonadError<E,B,M>` | MonadError.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `default <B> MonadWriter<W,B,MW>` | MonadWriter.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> SafeT<M,B>` | SafeT.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `default <B> Monad<B,M>` | Monad.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `default <B> MonadReader<R,B,MR>` | MonadReader.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `default <B> MonadRec<B,M>` | MonadRec.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> MonadWriter<W,Tuple2<A,B>,MW>` | MonadWriter.`listens(Fn1<? super W,? extends B> fn)` Map the accumulation into a value and pair it with the current output.
    `MonadReader<R,A,MR>` | MonadReader.`local(Fn1<? super R,? extends R> fn)` Modify this `MonadReader's` environment after reading it but before running the effect.
    `<B> MonadRec<B,M>` | MonadRec.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,M>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> SafeT<M,B>` | SafeT.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,SafeT<M,?>>> bounce)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.

    Method parameters in com.jnape.palatable.lambda.monad with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default <B> Lazy<? extends MonadError<E,B,M>>` | MonadError.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> 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.
    `default <B> Lazy<? extends Monad<B,M>>` | Monad.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> 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.
    `default <B> Lazy<? extends MonadRec<B,M>>` | MonadRec.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> 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.
    `default <B> Lazy<? extends MonadReader<R,B,MR>>` | MonadReader.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MR>> 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.
    `default <B> Lazy<? extends MonadWriter<W,B,MW>>` | MonadWriter.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MW>> 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> Lazy<SafeT<M,B>>` | SafeT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,SafeT<M,?>>> 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.
    `default <B> MonadError<E,B,M>` | MonadError.`zip(Applicative<Fn1<? super A,? extends B>,M> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `default <B> Monad<B,M>` | Monad.`zip(Applicative<Fn1<? super A,? extends B>,M> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `default <B> MonadRec<B,M>` | MonadRec.`zip(Applicative<Fn1<? super A,? extends B>,M> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `default <B> MonadReader<R,B,MR>` | MonadReader.`zip(Applicative<Fn1<? super A,? extends B>,MR> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `default <B> MonadWriter<W,B,MW>` | MonadWriter.`zip(Applicative<Fn1<? super A,? extends B>,MW> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<B> SafeT<M,B>` | SafeT.`zip(Applicative<Fn1<? super A,? extends B>,SafeT<M,?>> 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 Fn1 in com.jnape.palatable.lambda.monad.transformer

    Methods in com.jnape.palatable.lambda.monad.transformer with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<B> MonadT<M,B,MT,T>` | MonadT.`flatMap(Fn1<? super A,? extends Monad<B,MT>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `default <B> MonadT<M,B,MT,T>` | MonadT.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.

    Method parameters in com.jnape.palatable.lambda.monad.transformer with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default <B> Lazy<? extends MonadT<M,B,MT,T>>` | MonadT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MT>> 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.
    `default <B> MonadT<M,B,MT,T>` | MonadT.`zip(Applicative<Fn1<? super A,? extends B>,MT> 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 Fn1 in com.jnape.palatable.lambda.monad.transformer.builtin

    Methods in com.jnape.palatable.lambda.monad.transformer.builtin with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<L2,R2> EitherT<M,L2,R2>` | EitherT.`biMap(Fn1<? super L,? extends L2> lFn, Fn1<? super R,? extends R2> rFn)` Dually map covariantly over both the left and right parameters.
    `<L2,R2> EitherT<M,L2,R2>` | EitherT.`biMap(Fn1<? super L,? extends L2> lFn, Fn1<? super R,? extends R2> rFn)` Dually map covariantly over both the left and right parameters.
    `<L2> EitherT<M,L2,R>` | EitherT.`biMapL(Fn1<? super L,? extends L2> fn)` Covariantly map over the left parameter.
    `<R2> EitherT<M,L,R2>` | EitherT.`biMapR(Fn1<? super R,? extends R2> fn)` Covariantly map over the right parameter.
    `StateT<S,M,A>` | StateT.`censor(Fn1<? super S,? extends S> fn)` Update the accumulated state.
    `WriterT<W,M,A>` | WriterT.`censor(Fn1<? super W,? extends W> fn)` Update the accumulated state.
    `<Q> ReaderT<Q,M,A>` | ReaderT.`contraMap(Fn1<? super Q,? extends R> fn)` Contravariantly map `A <- B`.
    `<Q,B> ReaderT<Q,M,B>` | ReaderT.`diMap(Fn1<? super Q,? extends R> lFn, Fn1<? super A,? extends B> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<Q,B> ReaderT<Q,M,B>` | ReaderT.`diMap(Fn1<? super Q,? extends R> lFn, Fn1<? super A,? extends B> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `<Q> ReaderT<Q,M,A>` | ReaderT.`diMapL(Fn1<? super Q,? extends R> fn)` Contravariantly map over the left parameter.
    `<B> ReaderT<R,M,B>` | ReaderT.`diMapR(Fn1<? super A,? extends B> fn)` Covariantly map over the right parameter.
    `<B> IdentityT<M,B>` | IdentityT.`flatMap(Fn1<? super A,? extends Monad<B,IdentityT<M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> LazyT<M,B>` | LazyT.`flatMap(Fn1<? super A,? extends Monad<B,LazyT<M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> MaybeT<M,B>` | MaybeT.`flatMap(Fn1<? super A,? extends Monad<B,MaybeT<M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> ReaderT<R,M,B>` | ReaderT.`flatMap(Fn1<? super A,? extends Monad<B,ReaderT<R,M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> StateT<S,M,B>` | StateT.`flatMap(Fn1<? super A,? extends Monad<B,StateT<S,M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> WriterT<W,M,B>` | WriterT.`flatMap(Fn1<? super A,? extends Monad<B,WriterT<W,M,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<R2> EitherT<M,L,R2>` | EitherT.`flatMap(Fn1<? super R,? extends Monad<R2,EitherT<M,L,?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `<B> LazyT<M,B>` | LazyT.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> MaybeT<M,B>` | MaybeT.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> WriterT<W,M,B>` | WriterT.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> StateT<S,M,B>` | StateT.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> ReaderT<R,M,B>` | ReaderT.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> IdentityT<M,B>` | IdentityT.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<R2> EitherT<M,L,R2>` | EitherT.`fmap(Fn1<? super R,? extends R2> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `static <S,M extends MonadRec<?,M>,A> StateT<S,M,A>` | StateT.`gets(Fn1<? super S,? extends MonadRec<A,M>> fn)` Given a function that produces a value inside a `monadic effect` from a state, produce a `StateT` that simply passes its state to the function and applies it.
    `<B> StateT<S,M,Tuple2<A,B>>` | StateT.`listens(Fn1<? super S,? extends B> fn)` Map the accumulation into a value and pair it with the current output.
    `<B> WriterT<W,M,Tuple2<A,B>>` | WriterT.`listens(Fn1<? super W,? extends B> fn)` Map the accumulation into a value and pair it with the current output.
    `ReaderT<R,M,A>` | ReaderT.`local(Fn1<? super R,? extends R> fn)` Modify this `MonadReader's` environment after reading it but before running the effect.
    `StateT<S,M,A>` | StateT.`local(Fn1<? super S,? extends S> fn)` Modify this `MonadReader's` environment after reading it but before running the effect.
    `<MA extends MonadRec<A,M>,N extends MonadRec<?,N>,B> ReaderT<R,N,B>` | ReaderT.`mapReaderT(Fn1<? super MA,? extends MonadRec<B,N>> fn)` Map the current `monadic` embedding to a new one in a potentially different `Monad`.
    `<N extends MonadRec<?,N>,B> StateT<S,N,B>` | StateT.`mapStateT(Fn1<? super MonadRec<Tuple2<A,S>,M>,? extends MonadRec<Tuple2<B,S>,N>> fn)` Map both the result and the final state to a new result and final state inside the `Monad`.
    `static <S,M extends MonadRec<?,M>> StateT<S,M,Unit>` | StateT.`modify(Fn1<? super S,? extends MonadRec<S,M>> updateFn)` Lift a function that makes a stateful modification inside an `Monad` into `StateT`.
    `static <R,M extends MonadRec<?,M>,A> ReaderT<R,M,A>` | ReaderT.`readerT(Fn1<? super R,? extends MonadRec<A,M>> fn)` Lift a `function` (`R -> `Monad`<A, M>`) into a `ReaderT` instance.
    `static <S,M extends MonadRec<?,M>,A> StateT<S,M,A>` | StateT.`stateT(Fn1<? super S,? extends MonadRec<Tuple2<A,S>,M>> stateFn)` Lift a state-sensitive `monadically embedded` computation into `StateT`.
    `<B> IdentityT<M,B>` | IdentityT.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,IdentityT<M,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> LazyT<M,B>` | LazyT.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,LazyT<M,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> MaybeT<M,B>` | MaybeT.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,MaybeT<M,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> ReaderT<R,M,B>` | ReaderT.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,ReaderT<R,M,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> StateT<S,M,B>` | StateT.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,StateT<S,M,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B> WriterT<W,M,B>` | WriterT.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,WriterT<W,M,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<R2> EitherT<M,L,R2>` | EitherT.`trampolineM(Fn1<? super R,? extends MonadRec<RecursiveResult<R,R2>,EitherT<M,L,?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `StateT<S,M,A>` | StateT.`withStateT(Fn1<? super S,? extends MonadRec<S,M>> fn)` Map the final state to a new final state inside the same `monadic effect` using the provided function.

    Method parameters in com.jnape.palatable.lambda.monad.transformer.builtin with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<IdentityT<M,B>>` | IdentityT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,IdentityT<M,?>>> 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> Lazy<LazyT<M,B>>` | LazyT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,LazyT<M,?>>> 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> Lazy<MaybeT<M,B>>` | MaybeT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MaybeT<M,?>>> 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> Lazy<ReaderT<R,M,B>>` | ReaderT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,ReaderT<R,M,?>>> 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> Lazy<StateT<S,M,B>>` | StateT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,StateT<S,M,?>>> 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> Lazy<WriterT<W,M,B>>` | WriterT.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,WriterT<W,M,?>>> 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.
    `<R2> Lazy<EitherT<M,L,R2>>` | EitherT.`lazyZip(Lazy<? extends Applicative<Fn1<? super R,? extends R2>,EitherT<M,L,?>>> 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> IdentityT<M,B>` | IdentityT.`zip(Applicative<Fn1<? super A,? extends B>,IdentityT<M,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<B> LazyT<M,B>` | LazyT.`zip(Applicative<Fn1<? super A,? extends B>,LazyT<M,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<B> MaybeT<M,B>` | MaybeT.`zip(Applicative<Fn1<? super A,? extends B>,MaybeT<M,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<B> ReaderT<R,M,B>` | ReaderT.`zip(Applicative<Fn1<? super A,? extends B>,ReaderT<R,M,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<B> StateT<S,M,B>` | StateT.`zip(Applicative<Fn1<? super A,? extends B>,StateT<S,M,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<B> WriterT<W,M,B>` | WriterT.`zip(Applicative<Fn1<? super A,? extends B>,WriterT<W,M,?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `<R2> EitherT<M,L,R2>` | EitherT.`zip(Applicative<Fn1<? super R,? extends R2>,EitherT<M,L,?>> 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 Fn1 in com.jnape.palatable.lambda.monoid

    Subinterfaces of Fn1 in com.jnape.palatable.lambda.monoid
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Monoid<A>` A `Monoid` is the pairing of a `Semigroup` with an identity element.

    Methods in com.jnape.palatable.lambda.monoid with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default <B> A` | Monoid.`foldMap(Fn1<? super B,? extends A> fn, Iterable<B> bs)` Homomorphism combined with catamorphism.

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

    Classes in com.jnape.palatable.lambda.monoid.builtin that implement Fn1
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AddAll<A,C extends Collection<A>>` The `Monoid` instance formed under mutative concatenation for an arbitrary `Collection`.
    `class` | `And` A `Monoid` instance formed by `Boolean`.
    `class` | `Collapse<_1,_2>` A `Monoid` instance formed by a ``Tuple2`<_1, _2>` and monoids over `_1` and `_2`.
    `class` | `Compose<A>` A `Monoid` instance formed by ``CompletableFuture`<A>` and a monoid over `A`.
    `class` | `Concat<A>` The `Monoid` instance formed under concatenation for an arbitrary `Iterable`.
    `class` | `Endo<A>` A `Monoid` formed by `Fn1` under composition.
    `class` | `EndoK<M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>` The monoid formed under monadic endomorphism.
    `class` | `First<A>` A `Monoid` instance formed by ``Maybe`<A>`.
    `class` | `Join` A `Monoid` instance formed by `String` that concats two strings together.
    `class` | `LeftAll<L,R>` A `Monoid` instance formed by ``Either`<L,R>` and a monoid over `L`.
    `class` | `LeftAny<L,R>` A `Monoid` instance formed by ``Either`<L,R>` and a monoid over `L`.
    `class` | `Merge<L,R>` A `Monoid` instance formed by `Either.merge(com.jnape.palatable.lambda.functions.Fn2<? super L, ? super L, ? extends L>, com.jnape.palatable.lambda.functions.Fn2<? super R, ? super R, ? extends R>, com.jnape.palatable.lambda.adt.Either<L, R>...)`, a semigroup over `L`, and a monoid over `R`.
    `class` | `MergeMaps<K,V>` A `Monoid` instance formed by `Map.merge(Object, Object, BiFunction)` and a semigroup over `V`.
    `class` | `Or` A `Monoid` instance formed by `Boolean`.
    `class` | `Present<A>` A `Monoid` instance formed by ``Maybe`<A>` and a semigroup over `A`.
    `class` | `PutAll` A `Monoid` instance formed by `HMap` that simply combines all the mappings.
    `class` | `RightAll<L,R>` A `Monoid` instance formed by ``Either`<L,R>` and a monoid over `R`.
    `class` | `RightAny<L,R>` A `Monoid` instance formed by ``Either`<L,R>` and a monoid over `R`.
    `class` | `RunAll<A>` Run `IO` operations, aggregating their results in terms of the provided `Monoid`.
    `class` | `Trivial` The trivial `Unit` `Monoid` formed under `constantly`.
    `class` | `Union<A>` Given two `Iterables` `xs` and `ys`, return the `concatenation` of the `distinct` elements of both `xs` and `ys`.
    `class` | `Xor` Logical exclusive-or.

    Methods in com.jnape.palatable.lambda.monoid.builtin that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <A,C extends Collection<A>> Fn1<C,C>` | AddAll.`addAll(Fn0<C> collectionFn0, C xs)`
    `static Fn1<Boolean,Boolean>` | And.`and(Boolean x)`
    `Fn1<A,A>` | Endo.`checkedApply(Fn1<A,A> f, Fn1<A,A> g)`
    `static <_1,_2> Fn1<Tuple2<_1,_2>,Tuple2<_1,_2>>` | Collapse.`collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid, Tuple2<_1,_2> x)`
    `static <A> Fn1<CompletableFuture<A>,CompletableFuture<A>>` | Compose.`compose(Monoid<A> aMonoid, CompletableFuture<A> x)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | Concat.`concat(Iterable<A> xs)`
    `static <A> Fn1<A,A>` | Endo.`endo(Fn1<A,A> f, Fn1<A,A> g)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | First.`first(Maybe<A> x)`
    `Fn1<A,A>` | Endo.`identity()`
    `static Fn1<String,String>` | Join.`join(String x)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | Last.`last(Maybe<A> x)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | LeftAll.`leftAll(Monoid<L> lMonoid, Either<L,R> x)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | LeftAny.`leftAny(Monoid<L> lMonoid, Either<L,R> x)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | Merge.`merge(Semigroup<L> lSemigroup, Monoid<R> rMonoid, Either<L,R> x)`
    `static <K,V> Fn1<Map<K,V>,Map<K,V>>` | MergeMaps.`mergeMaps(Fn0<Map<K,V>> mFn0, Semigroup<V> semigroup, Map<K,V> x)`
    `static Fn1<Boolean,Boolean>` | Or.`or(Boolean x)`
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | Present.`present(Semigroup<A> aSemigroup, Maybe<A> x)`
    `static Fn1<HMap,HMap>` | PutAll.`putAll(HMap x)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | RightAll.`rightAll(Monoid<R> rMonoid, Either<L,R> x)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | RightAny.`rightAny(Monoid<R> rMonoid, Either<L,R> x)`
    `static <A> Fn1<IO<A>,IO<A>>` | RunAll.`runAll(Monoid<A> monoid, IO<A> x)`
    `static Fn1<Unit,Unit>` | Trivial.`trivial(Unit x)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | Union.`union(Iterable<A> xs)`
    `static Fn1<Boolean,Boolean>` | Xor.`xor(Boolean x)`

    Methods in com.jnape.palatable.lambda.monoid.builtin that return types with arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `Fn2<Fn1<A,A>,A,A>` | Endo.`apply(Fn1<A,A> f)`
    `Monoid<Fn1<A,MA>>` | EndoK.`checkedApply(Pure<M> pureM)`
    `static <A> Fn2<Fn1<A,A>,A,A>` | Endo.`endo(Fn1<A,A> f)`
    `static <M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>> Monoid<Fn1<A,MA>>` | EndoK.`endoK(Pure<M> pureM)`

    Methods in com.jnape.palatable.lambda.monoid.builtin with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `Fn2<Fn1<A,A>,A,A>` | Endo.`apply(Fn1<A,A> f)`
    `A` | Endo.`apply(Fn1<A,A> f, Fn1<A,A> g, A a)`
    `A` | Endo.`apply(Fn1<A,A> f, Fn1<A,A> g, A a)`
    `Fn1<A,A>` | Endo.`checkedApply(Fn1<A,A> f, Fn1<A,A> g)`
    `Fn1<A,A>` | Endo.`checkedApply(Fn1<A,A> f, Fn1<A,A> g)`
    `static <A> Fn2<Fn1<A,A>,A,A>` | Endo.`endo(Fn1<A,A> f)`
    `static <A> Fn1<A,A>` | Endo.`endo(Fn1<A,A> f, Fn1<A,A> g)`
    `static <A> Fn1<A,A>` | Endo.`endo(Fn1<A,A> f, Fn1<A,A> g)`
    `static <A> A` | Endo.`endo(Fn1<A,A> f, Fn1<A,A> g, A a)`
    `static <A> A` | Endo.`endo(Fn1<A,A> f, Fn1<A,A> g, A a)`
    `<B> Boolean` | And.`foldMap(Fn1<? super B,? extends Boolean> fn, Iterable<B> bs)`
    `<B> Boolean` | Or.`foldMap(Fn1<? super B,? extends Boolean> fn, Iterable<B> bs)`
    `<B> Iterable<A>` | Concat.`foldMap(Fn1<? super B,? extends Iterable<A>> fn, Iterable<B> bs)`
    `<B> Maybe<A>` | First.`foldMap(Fn1<? super B,? extends Maybe<A>> fn, Iterable<B> bs)`

  - ### Uses of Fn1 in com.jnape.palatable.lambda.optics

    Methods in com.jnape.palatable.lambda.optics that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default <CoP extends Profunctor<?,?,? extends P>,CoF extends Functor<?,? extends F>,FB extends Functor<B,? extends CoF>,FT extends Functor<T,? extends CoF>,PAFB extends Profunctor<A,FB,? extends CoP>,PSFT extends Profunctor<S,FT,? extends CoP>> Fn1<PAFB,PSFT>` | Optic.`monomorphize()` Produce a monomorphic `Fn1` backed by this `Optic`.

    Methods in com.jnape.palatable.lambda.optics that return types with arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default Tuple2<Fn1<? super S,? extends A>,Fn1<? super B,? extends T>>` | Iso.`unIso()` Destructure this `Iso` into the two functions `S -< A` and `B -< T` that constitute the isomorphism.
    `default Tuple2<Fn1<? super S,? extends A>,Fn1<? super B,? extends T>>` | Iso.`unIso()` Destructure this `Iso` into the two functions `S -< A` and `B -< T` that constitute the isomorphism.
    `default Tuple2<Fn1<? super B,? extends T>,Fn1<? super S,? extends Either<T,A>>>` | Prism.`unPrism()` Recover the two mappings encapsulated by this `Prism` by sending it through a `Market`.
    `default Tuple2<Fn1<? super B,? extends T>,Fn1<? super S,? extends Either<T,A>>>` | Prism.`unPrism()` Recover the two mappings encapsulated by this `Prism` by sending it through a `Market`.

    Methods in com.jnape.palatable.lambda.optics with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default <R> Prism<R,T,A,B>` | Prism.`contraMap(Fn1<? super R,? extends S> fn)` Contravariantly map `A <- B`.
    `default <R> Lens<R,T,A,B>` | Lens.`contraMap(Fn1<? super R,? extends S> fn)` Contravariantly map `A <- B`.
    `default <R> Iso<R,T,A,B>` | Iso.`contraMap(Fn1<? super R,? extends S> fn)` Contravariantly map `A <- B`.
    `default <R,U> Prism<R,U,A,B>` | Prism.`diMap(Fn1<? super R,? extends S> lFn, Fn1<? super T,? extends U> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `default <R,U> Prism<R,U,A,B>` | Prism.`diMap(Fn1<? super R,? extends S> lFn, Fn1<? super T,? extends U> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `default <R,U> Lens<R,U,A,B>` | Lens.`diMap(Fn1<? super R,? extends S> lFn, Fn1<? super T,? extends U> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `default <R,U> Lens<R,U,A,B>` | Lens.`diMap(Fn1<? super R,? extends S> lFn, Fn1<? super T,? extends U> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `default <R,U> Iso<R,U,A,B>` | Iso.`diMap(Fn1<? super R,? extends S> lFn, Fn1<? super T,? extends U> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `default <R,U> Iso<R,U,A,B>` | Iso.`diMap(Fn1<? super R,? extends S> lFn, Fn1<? super T,? extends U> rFn)` Dually map contravariantly over the left parameter and covariantly over the right parameter.
    `default <R> Prism<R,T,A,B>` | Prism.`diMapL(Fn1<? super R,? extends S> fn)` Contravariantly map over the left parameter.
    `default <R> Lens<R,T,A,B>` | Lens.`diMapL(Fn1<? super R,? extends S> fn)` Contravariantly map over the left parameter.
    `default <R> Iso<R,T,A,B>` | Iso.`diMapL(Fn1<? super R,? extends S> fn)` Contravariantly map over the left parameter.
    `default <U> Prism<S,U,A,B>` | Prism.`diMapR(Fn1<? super T,? extends U> fn)` Covariantly map over the right parameter.
    `default <U> Lens<S,U,A,B>` | Lens.`diMapR(Fn1<? super T,? extends U> fn)` Covariantly map over the right parameter.
    `default <U> Iso<S,U,A,B>` | Iso.`diMapR(Fn1<? super T,? extends U> fn)` Covariantly map over the right parameter.
    `default <U> Iso<S,U,A,B>` | Iso.`flatMap(Fn1<? super T,? extends Monad<U,Iso<S,?,A,B>>> fn)` Chain dependent computations that may continue or short-circuit based on previous results.
    `default <U> Lens<S,U,A,B>` | Lens.`flatMap(Fn1<? super T,? extends Monad<U,Lens<S,?,A,B>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `default <U> Prism<S,U,A,B>` | Prism.`flatMap(Fn1<? super T,? extends Monad<U,Prism<S,?,A,B>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `default <U> Prism<S,U,A,B>` | Prism.`fmap(Fn1<? super T,? extends U> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `default <U> Lens<S,U,A,B>` | Lens.`fmap(Fn1<? super T,? extends U> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `default <U> Iso<S,U,A,B>` | Iso.`fmap(Fn1<? super T,? extends U> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `static <S,A> Prism.Simple<S,A>` | Prism.Simple.`fromPartial(Fn1<? super S,? extends A> partialSa, Fn1<? super A,? extends S> as)` Static factory method for creating a `simple Prism` from a partial function `S -> A` and a total function `A -> T`.
    `static <S,A> Prism.Simple<S,A>` | Prism.Simple.`fromPartial(Fn1<? super S,? extends A> partialSa, Fn1<? super A,? extends S> as)` Static factory method for creating a `simple Prism` from a partial function `S -> A` and a total function `A -> T`.
    `static <S,A,B> Prism<S,S,A,B>` | Prism.`fromPartial(Fn1<? super S,? extends A> partialSa, Fn1<? super B,? extends S> bs)` Static factory method for creating a `Prism` from a partial function `S -> A` and a total function `B -> S`.
    `static <S,A,B> Prism<S,S,A,B>` | Prism.`fromPartial(Fn1<? super S,? extends A> partialSa, Fn1<? super B,? extends S> bs)` Static factory method for creating a `Prism` from a partial function `S -> A` and a total function `B -> S`.
    `static <S,T,A,B> Iso<S,T,A,B>` | Iso.`iso(Fn1<? super S,? extends A> f, Fn1<? super B,? extends T> g)` Static factory method for creating an iso from a function and it's inverse.
    `static <S,T,A,B> Iso<S,T,A,B>` | Iso.`iso(Fn1<? super S,? extends A> f, Fn1<? super B,? extends T> g)` Static factory method for creating an iso from a function and it's inverse.
    `static <S,T,A,B> Lens<S,T,A,B>` | Lens.`lens(Fn1<? super S,? extends A> getter, Fn2<? super S,? super B,? extends T> setter)` Static factory method for creating a lens from a getter function and a setter function.
    `default <C> Prism<S,T,C,B>` | Prism.`mapA(Fn1<? super A,? extends C> fn)` Covariantly map `A` to `C`, yielding a new optic.
    `default <C> Optic<P,F,S,T,C,B>` | Optic.`mapA(Fn1<? super A,? extends C> fn)` Covariantly map `A` to `C`, yielding a new optic.
    `default <C> Lens<S,T,C,B>` | Lens.`mapA(Fn1<? super A,? extends C> fn)` Covariantly map `A` to `C`, yielding a new optic.
    `default <C> ProtoOptic<P,S,T,C,B>` | ProtoOptic.`mapA(Fn1<? super A,? extends C> fn)` Covariantly map `A` to `C`, yielding a new optic.
    `default <C> Iso<S,T,C,B>` | Iso.`mapA(Fn1<? super A,? extends C> fn)` Covariantly map `A` to `C`, yielding a new optic.
    `default <Z> Prism<S,T,A,Z>` | Prism.`mapB(Fn1<? super Z,? extends B> fn)` Contravariantly map `B` to `Z`, yielding a new optic.
    `default <Z> Optic<P,F,S,T,A,Z>` | Optic.`mapB(Fn1<? super Z,? extends B> fn)` Contravariantly map `B` to `Z`, yielding a new optic.
    `default <Z> Lens<S,T,A,Z>` | Lens.`mapB(Fn1<? super Z,? extends B> fn)` Contravariantly map `B` to `Z`, yielding a new optic.
    `default <Z> ProtoOptic<P,S,T,A,Z>` | ProtoOptic.`mapB(Fn1<? super Z,? extends B> fn)` Contravariantly map `B` to `Z`, yielding a new optic.
    `default <Z> Iso<S,T,A,Z>` | Iso.`mapB(Fn1<? super Z,? extends B> fn)` Contravariantly map `B` to `Z`, yielding a new optic.
    `default <R> Prism<R,T,A,B>` | Prism.`mapS(Fn1<? super R,? extends S> fn)` Contravariantly map `S` to `R`, yielding a new optic.
    `default <R> Optic<P,F,R,T,A,B>` | Optic.`mapS(Fn1<? super R,? extends S> fn)` Contravariantly map `S` to `R`, yielding a new optic.
    `default <R> Lens<R,T,A,B>` | Lens.`mapS(Fn1<? super R,? extends S> fn)` Contravariantly map `S` to `R`, yielding a new optic.
    `default <R> ProtoOptic<P,R,T,A,B>` | ProtoOptic.`mapS(Fn1<? super R,? extends S> fn)` Contravariantly map `S` to `R`, yielding a new optic.
    `default <R> Iso<R,T,A,B>` | Iso.`mapS(Fn1<? super R,? extends S> fn)` Contravariantly map `S` to `R`, yielding a new optic.
    `default <U> Prism<S,U,A,B>` | Prism.`mapT(Fn1<? super T,? extends U> fn)` Covariantly map `T` to `U`, yielding a new optic.
    `default <U> Optic<P,F,S,U,A,B>` | Optic.`mapT(Fn1<? super T,? extends U> fn)` Covariantly map `T` to `U`, yielding a new optic.
    `default <U> Lens<S,U,A,B>` | Lens.`mapT(Fn1<? super T,? extends U> fn)` Covariantly map `T` to `U`, yielding a new optic.
    `default <U> ProtoOptic<P,S,U,A,B>` | ProtoOptic.`mapT(Fn1<? super T,? extends U> fn)` Covariantly map `T` to `U`, yielding a new optic.
    `default <U> Iso<S,U,A,B>` | Iso.`mapT(Fn1<? super T,? extends U> fn)` Covariantly map `T` to `U`, yielding a new optic.
    `static <P extends Profunctor<?,?,? extends P>,F extends Functor<?,? extends F>,S,T,A,B,FB extends Functor<B,? extends F>,FT extends Functor<T,? extends F>,PAFB extends Profunctor<A,FB,? extends P>,PSFT extends Profunctor<S,FT,? extends P>> Optic<P,F,S,T,A,B>` | Optic.`optic(Fn1<PAFB,PSFT> fn)` Promote a monomorphic function to a compatible `Optic`.
    `static <S,T,A,B> Prism<S,T,A,B>` | Prism.`prism(Fn1<? super S,? extends CoProduct2<T,A,?>> sta, Fn1<? super B,? extends T> bt)` Static factory method for creating a `Prism` given a mapping from `S -> `Either`<T, A>` and a mapping from `B -> T`.
    `static <S,T,A,B> Prism<S,T,A,B>` | Prism.`prism(Fn1<? super S,? extends CoProduct2<T,A,?>> sta, Fn1<? super B,? extends T> bt)` Static factory method for creating a `Prism` given a mapping from `S -> `Either`<T, A>` and a mapping from `B -> T`.
    `static <S,A,B> Pure<Iso<S,?,A,B>>` | Iso.`pureIso(Fn1<? super S,? extends A> sa)` The canonical `Pure` instance for `Iso`.
    `static <S,A,B> Pure<Lens<S,?,A,B>>` | Lens.`pureLens(Fn1<? super S,? extends A> sa)` The canonical `Pure` instance for `Lens`.
    `static <S,A> Iso.Simple<S,A>` | Iso.`simpleIso(Fn1<? super S,? extends A> f, Fn1<? super A,? extends S> g)` Static factory method for creating a simple `Iso` from a function and its inverse.
    `static <S,A> Iso.Simple<S,A>` | Iso.`simpleIso(Fn1<? super S,? extends A> f, Fn1<? super A,? extends S> g)` Static factory method for creating a simple `Iso` from a function and its inverse.
    `static <S,A> Lens.Simple<S,A>` | Lens.`simpleLens(Fn1<? super S,? extends A> getter, Fn2<? super S,? super A,? extends S> setter)` Static factory method for creating a simple lens from a getter function and a setter function.
    `static <S,A> Prism.Simple<S,A>` | Prism.`simplePrism(Fn1<? super S,? extends Maybe<A>> sMaybeA, Fn1<? super A,? extends S> as)` Static factory method for creating a simple `Prism` from a function and its potentially failing inverse.
    `static <S,A> Prism.Simple<S,A>` | Prism.`simplePrism(Fn1<? super S,? extends Maybe<A>> sMaybeA, Fn1<? super A,? extends S> as)` Static factory method for creating a simple `Prism` from a function and its potentially failing inverse.
    `default <U> Iso<S,U,A,B>` | Iso.`trampolineM(Fn1<? super T,? extends MonadRec<RecursiveResult<T,U>,Iso<S,?,A,B>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `default <U> Lens<S,U,A,B>` | Lens.`trampolineM(Fn1<? super T,? extends MonadRec<RecursiveResult<T,U>,Lens<S,?,A,B>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `default <U> Prism<S,U,A,B>` | Prism.`trampolineM(Fn1<? super T,? extends MonadRec<RecursiveResult<T,U>,Prism<S,?,A,B>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.

    Method parameters in com.jnape.palatable.lambda.optics with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `default <U> Lazy<Prism<S,U,A,B>>` | Prism.`lazyZip(Lazy<? extends Applicative<Fn1<? super T,? extends U>,Prism<S,?,A,B>>> 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.
    `default <U> Iso<S,U,A,B>` | Iso.`zip(Applicative<Fn1<? super T,? extends U>,Iso<S,?,A,B>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `default <U> Lens<S,U,A,B>` | Lens.`zip(Applicative<Fn1<? super T,? extends U>,Lens<S,?,A,B>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    `default <U> Prism<S,U,A,B>` | Prism.`zip(Applicative<Fn1<? super T,? extends U>,Prism<S,?,A,B>> 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 Fn1 in com.jnape.palatable.lambda.optics.functions

    Classes in com.jnape.palatable.lambda.optics.functions that implement Fn1
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Matching<S,T,A,B>`
    `class` | `Over<S,T,A,B>` Given an `Optic`, a function from `A` to `B`, and a "larger" value `S`, produce a `T` by retrieving the `A` from the `S`, applying the function, and updating the `S` with the `B` resulting from the function.
    `class` | `Pre<P extends Profunctor<?,?,? extends P>,S,T,A,B>` Turn an `Optic` with a unary mapping that can be used for viewing some number of values into an `Optic` that views the first value, if it exists.
    `class` | `Re<S,T,A,B>` Turn an `Optic` with a unary mapping that can be used for setting (e.g.
    `class` | `Set<S,T,A,B>` Given an `Optic`, a "smaller" value `B`, and a "larger" value `S`, produce a `T` by lifting the `Optic` into the `Identity` functor.
    `class` | `Under<S,T,A,B>` The inverse of `Over`: given an `Iso`, a function from `T` to `S`, and a "smaller" value `B`, return a "smaller" value `A` by traversing around the type ring (`B -> T -> S -> A`).
    `class` | `View<S,T,A,B>` Given an `Optic` and a "larger" value `S`, retrieve a "smaller" value `A` by lifting the `Optic` into the `Const` functor.

    Methods in com.jnape.palatable.lambda.optics.functions that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <S,T,A,B> Fn1<S,Either<T,A>>` | Matching.`matching(Optic<? super Market<A,B,?,?>,? super Identity<?>,S,T,A,B> optic)`
    `static <S,T,A,B> Fn1<S,T>` | Over.`over(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic, Fn1<? super A,? extends B> fn)`
    `static <S,T,A,B> Fn1<S,T>` | Set.`set(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic, B b)`
    `static <S,T,A,B> Fn1<B,A>` | Under.`under(Optic<? super Exchange<A,B,?,?>,? super Identity<?>,S,T,A,B> optic, Fn1<? super T,? extends S> fn)`
    `static <S,T,A,B> Fn1<S,A>` | View.`view(Optic<? super Fn1<?,?>,? super Const<A,?>,S,T,A,B> optic)`

    Methods in com.jnape.palatable.lambda.optics.functions that return types with arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <S,T,A,B> Fn2<Fn1<? super A,? extends B>,S,T>` | Over.`over(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic)`
    `static <S,T,A,B> Fn2<Fn1<? super T,? extends S>,B,A>` | Under.`under(Optic<? super Exchange<A,B,?,?>,? super Identity<?>,S,T,A,B> optic)`

    Methods in com.jnape.palatable.lambda.optics.functions with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `A` | Under.`checkedApply(Optic<? super Exchange<A,B,?,?>,? super Identity<?>,S,T,A,B> optic, Fn1<? super T,? extends S> fn, B b)`
    `T` | Over.`checkedApply(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic, Fn1<? super A,? extends B> fn, S s)`
    `static <S,T,A,B> Fn1<S,T>` | Over.`over(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic, Fn1<? super A,? extends B> fn)`
    `static <S,T,A,B> T` | Over.`over(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic, Fn1<? super A,? extends B> fn, S s)`
    `static <S,T,A,B> Fn1<B,A>` | Under.`under(Optic<? super Exchange<A,B,?,?>,? super Identity<?>,S,T,A,B> optic, Fn1<? super T,? extends S> fn)`
    `static <S,T,A,B> A` | Under.`under(Optic<? super Exchange<A,B,?,?>,? super Identity<?>,S,T,A,B> optic, Fn1<? super T,? extends S> fn, B b)`

    Method parameters in com.jnape.palatable.lambda.optics.functions with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `A` | View.`checkedApply(Optic<? super Fn1<?,?>,? super Const<A,?>,S,T,A,B> optic, S s)`
    `T` | Set.`checkedApply(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic, B b, S s)`
    `T` | Over.`checkedApply(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic, Fn1<? super A,? extends B> fn, S s)`
    `static <S,T,A,B> Fn2<Fn1<? super A,? extends B>,S,T>` | Over.`over(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic)`
    `static <S,T,A,B> Fn1<S,T>` | Over.`over(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic, Fn1<? super A,? extends B> fn)`
    `static <S,T,A,B> T` | Over.`over(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic, Fn1<? super A,? extends B> fn, S s)`
    `static <S,T,A,B> Fn2<B,S,T>` | Set.`set(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic)`
    `static <S,T,A,B> Fn1<S,T>` | Set.`set(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic, B b)`
    `static <S,T,A,B> T` | Set.`set(Optic<? super Fn1<?,?>,? super Identity<?>,S,T,A,B> optic, B b, S s)`
    `static <S,T,A,B> Fn1<S,A>` | View.`view(Optic<? super Fn1<?,?>,? super Const<A,?>,S,T,A,B> optic)`
    `static <S,T,A,B> A` | View.`view(Optic<? super Fn1<?,?>,? super Const<A,?>,S,T,A,B> optic, S s)`

  - ### Uses of Fn1 in com.jnape.palatable.lambda.optics.lenses

    Methods in com.jnape.palatable.lambda.optics.lenses with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <X,CX extends Collection<X>> Lens.Simple<CX,CX>` | CollectionLens.`asCopy(Fn1<? super CX,? extends CX> copyFn)` Convenience static factory method for creating a lens that focuses on a copy of a `Collection`, given a function that creates the copy.
    `static <M extends Map<K,V>,K,V> Lens<Map<K,V>,M,M,M>` | MapLens.`asCopy(Fn1<? super Map<K,V>,? extends M> copyFn)` A lens that focuses on a copy of a `Map` as a subtype `M`.
    `static <X,CX extends Collection<X>> Lens.Simple<CX,Set<X>>` | CollectionLens.`asSet(Fn1<? super CX,? extends CX> copyFn)` Convenience static factory method for creating a lens that focuses on an arbitrary `Collection` as a `Set`.
    `static <X,CX extends Collection<X>> Lens.Simple<CX,Stream<X>>` | CollectionLens.`asStream(Fn1<? super CX,? extends CX> copyFn)` Convenience static factory method for creating a lens that focuses on a Collection as a Stream.
    `static <A,SetA extends Set<A>> Lens.Simple<SetA,Boolean>` | SetLens.`contains(Fn1<? super SetA,? extends SetA> copyFn, A a)` A lens that focuses on whether a `Set` contains some value `a`.
    `static <M extends Map<K,V>,K,V> Lens<Map<K,V>,M,Maybe<V>,Maybe<V>>` | MapLens.`valueAt(Fn1<? super Map<K,V>,? extends M> copyFn, K k)` A lens that focuses on a value at a key in a map, as a `Maybe`, and produces a subtype `M` on the way back out.

  - ### Uses of Fn1 in com.jnape.palatable.lambda.optics.prisms

    Methods in com.jnape.palatable.lambda.optics.prisms with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <M extends Map<K,V>,K,V> Prism<Map<K,V>,M,V,V>` | MapPrism.`valueAt(Fn1<Map<K,V>,M> copyFn, K k)` A `Prism` that focuses on the value at a key in a `Map`, and produces an instance of `M` on the way back out.

  - ### Uses of Fn1 in com.jnape.palatable.lambda.semigroup

    Subinterfaces of Fn1 in com.jnape.palatable.lambda.semigroup
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Semigroup<A>` A `Semigroup` is a closed, associative category.

  - ### Uses of Fn1 in com.jnape.palatable.lambda.semigroup.builtin

    Classes in com.jnape.palatable.lambda.semigroup.builtin that implement Fn1
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Absent<A>` A `Semigroup` instance formed by ``Maybe`<A>` and a semigroup over `A`.
    `class` | `Intersection<A>` Given two `Iterables` `xs` and `ys`, return the `distinct` elements of `xs` that are also in `ys` in order of their unique occurrence in `xs`.
    `class` | `Max<A extends Comparable<A>>` A `Semigroup` over `A` that chooses between two values `x` and `y` via the following rules: If `x` is strictly less than `y`, return `y` Otherwise, return `x`
    `class` | `MaxBy<A,B extends Comparable<B>>` Given a mapping function from some type `A` to some `Comparable` type `B`, produce a `Semigroup` over `A` that chooses between two values `x` and `y` via the following rules: If `x` is strictly less than `y` in terms of `B`, return `y` Otherwise, return `x`
    `class` | `Min<A extends Comparable<A>>` A `Semigroup` over `A` that chooses between two values `x` and `y` via the following rules: If `x` is strictly greater than `y`, return `y` Otherwise, return `x`
    `class` | `MinBy<A,B extends Comparable<B>>` Given a mapping function from some type `A` to some `Comparable` type `B`, produce a `Semigroup` over `A` that chooses between two values `x` and `y` via the following rules: If `x` is strictly greater than `y` in terms of `B`, return `y` Otherwise, return `x`

    Methods in com.jnape.palatable.lambda.semigroup.builtin that return Fn1
    Modifier and Type | Method and Description
    --- | ---
    `static <A> Fn1<Maybe<A>,Maybe<A>>` | Absent.`absent(Semigroup<A> aSemigroup, Maybe<A> x)`
    `static <_1,_2> Fn1<Tuple2<_1,_2>,Tuple2<_1,_2>>` | Collapse.`collapse(Semigroup<_1> _1Semigroup, Semigroup<_2> _2Semigroup, Tuple2<_1,_2> x)`
    `static <A> Fn1<CompletableFuture<A>,CompletableFuture<A>>` | Compose.`compose(Semigroup<A> aSemigroup, CompletableFuture<A> x)`
    `static <A> Fn1<Iterable<A>,Iterable<A>>` | Intersection.`intersection(Iterable<A> xs)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | LeftAll.`leftAll(Semigroup<L> lSemigroup, Either<L,R> x)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | LeftAny.`leftAny(Semigroup<L> lSemigroup, Either<L,R> x)`
    `static <A extends Comparable<A>> Fn1<A,A>` | Max.`max(A x)`
    `static <A,B extends Comparable<B>> Fn1<A,A>` | MaxBy.`maxBy(Fn1<? super A,? extends B> compareFn, A x)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | Merge.`merge(Semigroup<L> lSemigroup, Semigroup<R> rSemigroup, Either<L,R> x)`
    `static <A extends Comparable<A>> Fn1<A,A>` | Min.`min(A x)`
    `static <A,B extends Comparable<B>> Fn1<A,A>` | MinBy.`minBy(Fn1<? super A,? extends B> compareFn, A x)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | RightAll.`rightAll(Semigroup<R> rSemigroup, Either<L,R> x)`
    `static <L,R> Fn1<Either<L,R>,Either<L,R>>` | RightAny.`rightAny(Semigroup<R> rSemigroup, Either<L,R> x)`
    `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 Fn1
    Modifier and Type | Method and Description
    --- | ---
    `Semigroup<A>` | MinBy.`checkedApply(Fn1<? super A,? extends B> compareFn)`
    `Semigroup<A>` | MaxBy.`checkedApply(Fn1<? super A,? extends B> compareFn)`
    `static <A,B extends Comparable<B>> Semigroup<A>` | MaxBy.`maxBy(Fn1<? super A,? extends B> compareFn)`
    `static <A,B extends Comparable<B>> Fn1<A,A>` | MaxBy.`maxBy(Fn1<? super A,? extends B> compareFn, A x)`
    `static <A,B extends Comparable<B>> A` | MaxBy.`maxBy(Fn1<? super A,? extends B> compareFn, A x, A y)`
    `static <A,B extends Comparable<B>> Semigroup<A>` | MinBy.`minBy(Fn1<? super A,? extends B> compareFn)`
    `static <A,B extends Comparable<B>> Fn1<A,A>` | MinBy.`minBy(Fn1<? super A,? extends B> compareFn, A x)`
    `static <A,B extends Comparable<B>> A` | MinBy.`minBy(Fn1<? super A,? extends B> compareFn, A x, A y)`

  - ### Uses of Fn1 in com.jnape.palatable.lambda.traversable

    Methods in com.jnape.palatable.lambda.traversable with parameters of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<B> LambdaIterable<B>` | LambdaIterable.`flatMap(Fn1<? super A,? extends Monad<B,LambdaIterable<?>>> f)` Chain dependent computations that may continue or short-circuit based on previous results.
    `default <B> Traversable<B,T>` | Traversable.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<B> LambdaIterable<B>` | LambdaIterable.`fmap(Fn1<? super A,? extends B> fn)` Covariantly transmute this functor's parameter using the given mapping function.
    `<C> LambdaMap<A,C>` | LambdaMap.`fmap(Fn1<? super B,? extends C> fn)`
    `<B> LambdaIterable<B>` | LambdaIterable.`trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,LambdaIterable<?>>> fn)` Given some operation yielding a `RecursiveResult` inside this `MonadRec`, internally trampoline the operation until it yields a `termination` instruction.
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,LambdaIterable<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | LambdaIterable.`traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,LambdaIterable<?>>,AppTrav extends Applicative<TravB,App>> AppTrav` | LambdaIterable.`traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,T>,AppTrav extends Applicative<TravB,App>> AppTrav` | Traversable.`traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<B,App extends Applicative<?,App>,TravB extends Traversable<B,T>,AppTrav extends Applicative<TravB,App>> AppTrav` | Traversable.`traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)` Apply `fn` to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
    `<C,App extends Applicative<?,App>,TravC extends Traversable<C,LambdaMap<A,?>>,AppTrav extends Applicative<TravC,App>> AppTrav` | LambdaMap.`traverse(Fn1<? super B,? extends Applicative<C,App>> fn, Fn1<? super TravC,? extends AppTrav> pure)`
    `<C,App extends Applicative<?,App>,TravC extends Traversable<C,LambdaMap<A,?>>,AppTrav extends Applicative<TravC,App>> AppTrav` | LambdaMap.`traverse(Fn1<? super B,? extends Applicative<C,App>> fn, Fn1<? super TravC,? extends AppTrav> pure)`

    Method parameters in com.jnape.palatable.lambda.traversable with type arguments of type Fn1
    Modifier and Type | Method and Description
    --- | ---
    `<B> Lazy<LambdaIterable<B>>` | LambdaIterable.`lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,LambdaIterable<?>>> 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> LambdaIterable<B>` | LambdaIterable.`zip(Applicative<Fn1<? super A,? extends B>,LambdaIterable<?>> appFn)` Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.