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

- Packages that use Fn3
  Package | Description
  --- | ---
  com.jnape.palatable.lambda.adt.product |
  com.jnape.palatable.lambda.functions |
  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.specialized |
  com.jnape.palatable.lambda.monoid.builtin |
  com.jnape.palatable.lambda.optics.functions |
  com.jnape.palatable.lambda.semigroup.builtin |

- - ### Uses of Fn3 in com.jnape.palatable.lambda.adt.product

    Methods in com.jnape.palatable.lambda.adt.product with parameters of type Fn3
    Modifier and Type | Method and Description
    --- | ---
    `default <R> R` | Product3.`into(Fn3<? super _1,? super _2,? super _3,? extends R> fn)` Destructure and apply this product to a function accepting the same number of arguments as this product's slots.

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

    Subinterfaces of Fn3 in com.jnape.palatable.lambda.functions
    Modifier and Type | Interface and Description
    --- | ---
    `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 Fn3
    Modifier and Type | Method and Description
    --- | ---
    `default Fn3<B,C,D,E>` | Fn4.`apply(A a)` Partially apply this function by taking its first argument.
    `default Fn3<C,D,E,F>` | Fn5.`apply(A a, B b)` Partially apply this function by taking its first two arguments.
    `default Fn3<D,E,F,G>` | Fn6.`apply(A a, B b, C c)` Partially apply this function by taking its first three arguments.
    `default Fn3<E,F,G,H>` | Fn7.`apply(A a, B b, C c, D d)` Partially apply this function by taking its first four arguments.
    `default Fn3<F,G,H,I>` | Fn8.`apply(A a, B b, C c, D d, E e)` Partially apply this function by taking its first five arguments.
    `default <Y,Z> Fn3<Y,Z,B,C>` | Fn2.`compose(Fn2<? super Y,? super Z,? extends A> before)` Right-to-left composition between different arity functions.
    `default <Z> Fn3<Z,B,C,D>` | Fn3.`contraMap(Fn1<? super Z,? extends A> fn)`
    `default <Z> Fn3<Z,B,C,D>` | Fn3.`diMapL(Fn1<? super Z,? extends A> fn)`
    `default <E> Fn3<A,B,C,D>` | Fn3.`discardR(Applicative<E,Fn1<A,?>> appB)`
    `default Fn3<B,A,C,D>` | Fn3.`flip()` Flip the order of the first two arguments.
    `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> 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> Fn3<A,B,C,D>` | Fn3.`fn3(Fn3<A,B,C,D> fn)` Static factory method for coercing a lambda to an `Fn3`.
    `default Fn3<? super Product2<? extends A,? extends B>,C,D,E>` | Fn4.`uncurry()` Returns an `Fn3` that takes the first two arguments as a ``Product2`<A, B>` and the third and fourth arguments.
    `default <Z> Fn3<Z,A,B,C>` | Fn2.`widen()` Widen this function's argument list by prepending an ignored argument of any type to the front.

    Methods in com.jnape.palatable.lambda.functions with parameters of type Fn3
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B,C,D> Fn3<A,B,C,D>` | Fn3.`fn3(Fn3<A,B,C,D> fn)` Static factory method for coercing a lambda to 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(Fn3<A,B,C,Fn2<D,E,F>> curriedFn3)` Static factory method for wrapping a curried `Fn3` in an `Fn5`.
    `static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G>` | Fn6.`fn6(Fn3<A,B,C,Fn3<D,E,F,G>> curriedFn3)` Static factory method for wrapping a curried `Fn3` in an `Fn6`.
    `static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H>` | Fn7.`fn7(Fn3<A,B,C,Fn4<D,E,F,G,H>> curriedFn3)` Static factory method for wrapping a curried `Fn3` 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(Fn3<A,B,C,Fn5<D,E,F,G,H,I>> curriedFn3)` Static factory method for wrapping a curried `Fn3` in an `Fn8`.

    Method parameters in com.jnape.palatable.lambda.functions with type arguments of type Fn3
    Modifier and Type | Method and Description
    --- | ---
    `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(Fn2<A,B,Fn3<C,D,E,F>> curriedFn2)` Static factory method for wrapping a curried `Fn2` in an `Fn5`.
    `static <A,B,C,D,E,F,G> Fn6<A,B,C,D,E,F,G>` | Fn6.`fn6(Fn3<A,B,C,Fn3<D,E,F,G>> curriedFn3)` Static factory method for wrapping a curried `Fn3` in an `Fn6`.
    `static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H>` | Fn7.`fn7(Fn4<A,B,C,D,Fn3<E,F,G,H>> curriedFn4)` Static factory method for wrapping a curried `Fn4` 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(Fn5<A,B,C,D,E,Fn3<F,G,H,I>> curriedFn5)` Static factory method for wrapping a curried `Fn5` in an `Fn8`.

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

    Classes in com.jnape.palatable.lambda.functions.builtin.fn2 that implement Fn3
    Modifier and Type | Class and Description
    --- | ---
    `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` | `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

    Methods in com.jnape.palatable.lambda.functions.builtin.fn2 with parameters of type Fn3
    Modifier and Type | Method and Description
    --- | ---
    `D` | Into3.`checkedApply(Fn3<? super A,? super B,? super C,? extends D> fn, Product3<A,B,C> product)`
    `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> D` | Into3.`into3(Fn3<? super A,? super B,? super C,? extends D> fn, Product3<A,B,C> product)`

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

    Classes in com.jnape.palatable.lambda.functions.builtin.fn3 that implement Fn3
    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.

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

    Classes in com.jnape.palatable.lambda.functions.builtin.fn4 that implement Fn3
    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 Fn3
    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,C,D,App extends Applicative<?,App>,AppD extends Applicative<D,App>> Fn3<Applicative<A,App>,Applicative<B,App>,Applicative<C,App>,AppD>` | LiftA3.`liftA3(Fn3<A,B,C,D> fn)`
    `static <A> Fn3<Long,Duration,Iterable<A>,Iterable<A>>` | RateLimit.`rateLimit(Fn0<Instant> instantFn0)`

    Methods in com.jnape.palatable.lambda.functions.builtin.fn4 with parameters of type Fn3
    Modifier and Type | Method and Description
    --- | ---
    `AppD` | LiftA3.`checkedApply(Fn3<A,B,C,D> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC)`
    `static <A,B,C,D,App extends Applicative<?,App>,AppD extends Applicative<D,App>> Fn3<Applicative<A,App>,Applicative<B,App>,Applicative<C,App>,AppD>` | LiftA3.`liftA3(Fn3<A,B,C,D> fn)`
    `static <A,B,C,D,App extends Applicative<?,App>,AppD extends Applicative<D,App>> Fn2<Applicative<B,App>,Applicative<C,App>,AppD>` | LiftA3.`liftA3(Fn3<A,B,C,D> fn, Applicative<A,App> appA)`
    `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,B,C,D,App extends Applicative<?,App>,AppD extends Applicative<D,App>> AppD` | LiftA3.`liftA3(Fn3<A,B,C,D> fn, Applicative<A,App> appA, Applicative<B,App> appB, Applicative<C,App> appC)`

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

    Classes in com.jnape.palatable.lambda.functions.builtin.fn5 that implement Fn3
    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 Fn3
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B,C,D,E,App extends Applicative<?,App>,AppE extends Applicative<E,App>> Fn3<Applicative<B,App>,Applicative<C,App>,Applicative<D,App>,AppE>` | LiftA4.`liftA4(Fn4<A,B,C,D,E> fn, Applicative<A,App> appA)`

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

    Classes in com.jnape.palatable.lambda.functions.builtin.fn6 that implement Fn3
    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 Fn3
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B,C,D,E,F,App extends Applicative<?,App>,AppF extends Applicative<F,App>> Fn3<Applicative<C,App>,Applicative<D,App>,Applicative<E,App>,AppF>` | LiftA5.`liftA5(Fn5<A,B,C,D,E,F> fn, Applicative<A,App> appA, Applicative<B,App> appB)`

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

    Classes in com.jnape.palatable.lambda.functions.builtin.fn7 that implement Fn3
    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 Fn3
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B,C,D,E,F,G,App extends Applicative<?,App>,AppG extends Applicative<G,App>> Fn3<Applicative<D,App>,Applicative<E,App>,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)`

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

    Classes in com.jnape.palatable.lambda.functions.builtin.fn8 that implement Fn3
    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 Fn3
    Modifier and Type | Method and Description
    --- | ---
    `static <A,B,C,D,E,F,G,H,App extends Applicative<?,App>,AppH extends Applicative<H,App>> Fn3<Applicative<E,App>,Applicative<F,App>,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)`

  - ### Uses of Fn3 in com.jnape.palatable.lambda.functions.specialized

    Subinterfaces of Fn3 in com.jnape.palatable.lambda.functions.specialized
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BiMonoidFactory<A,B,C>`
    `interface` | `BiSemigroupFactory<A,B,C>`
    `interface` | `MonoidFactory<A,B>`
    `interface` | `SemigroupFactory<A,B>`

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

    Classes in com.jnape.palatable.lambda.monoid.builtin that implement Fn3
    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` | `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` | `EndoK<M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>` The monoid formed under monadic endomorphism.
    `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` | `Present<A>` A `Monoid` instance formed by ``Maybe`<A>` and a semigroup over `A`.
    `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`.

  - ### Uses of Fn3 in com.jnape.palatable.lambda.optics.functions

    Classes in com.jnape.palatable.lambda.optics.functions that implement Fn3
    Modifier and Type | Class and Description
    --- | ---
    `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` | `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`).

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

    Classes in com.jnape.palatable.lambda.semigroup.builtin that implement Fn3
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Absent<A>` A `Semigroup` instance formed by ``Maybe`<A>` and a semigroup over `A`.
    `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` | `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`