com.jnape.palatable.lambda.functions

## Interface Fn3<A,B,C,D>

- Type Parameters:
    `A` - The first argument type
    `B` - The second argument type
    `C` - The third argument type
    `D` - The return type
  All Superinterfaces:
    Applicative<Fn1<B,Fn1<C,D>>,Fn1<A,?>>, Cartesian<A,Fn1<B,Fn1<C,D>>,Fn1<?,?>>, Cocartesian<A,Fn1<B,Fn1<C,D>>,Fn1<?,?>>, Contravariant<A,Profunctor<?,Fn1<B,Fn1<C,D>>,Fn1<?,?>>>, Fn1<A,Fn1<B,Fn1<C,D>>>, Fn2<A,B,Fn1<C,D>>, Functor<Fn1<B,Fn1<C,D>>,Fn1<A,?>>, Monad<Fn1<B,Fn1<C,D>>,Fn1<A,?>>, MonadReader<A,Fn1<B,Fn1<C,D>>,Fn1<A,?>>, MonadRec<Fn1<B,Fn1<C,D>>,Fn1<A,?>>, MonadWriter<A,Fn1<B,Fn1<C,D>>,Fn1<A,?>>, Profunctor<A,Fn1<B,Fn1<C,D>>,Fn1<?,?>>
  All Known Subinterfaces:
    BiMonoidFactory<A,B,C>, BiSemigroupFactory<A,B,C>, Fn4<A,B,C,D,E>, Fn5<A,B,C,D,E,F>, Fn6<A,B,C,D,E,F,G>, Fn7<A,B,C,D,E,F,G,H>, Fn8<A,B,C,D,E,F,G,H,I>, MonoidFactory<A,B>, SemigroupFactory<A,B>
  All Known Implementing Classes:
    Absent, AddAll, Between, Both, Bracket, Clamp, CmpEqBy, Collapse, Collapse, Compose, Compose, EndoK, FoldLeft, FoldRight, GTBy, GTEBy, IfThenElse, LeftAll, LeftAll, LeftAny, LeftAny, LiftA2, LiftA3, LiftA4, LiftA5, LiftA6, LiftA7, LTBy, LTEBy, MaxBy, Merge, Merge, MergeMaps, MinBy, Over, Peek2, Present, RateLimit, RightAll, RightAll, RightAny, RightAny, RunAll, RunAll, ScanLeft, Set, Times, Under, ZipWith
  Functional Interface:
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

      @FunctionalInterface
      public interface Fn3<A,B,C,D>
      extends Fn2<A,B,Fn1<C,D>>

  A function taking three arguments. Defined in terms of `Fn2`, so similarly auto-curried.
  See Also:
    `Fn2`

- - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `default Fn2<B,C,D>` | `apply(A a)` Partially apply this function by taking its first argument.
    `default Fn1<C,D>` | `apply(A a, B b)` Partially apply this function by taking its first two arguments.
    `default D` | `apply(A a, B b, C c)` Invoke this function with the given arguments.
    `default Fn1<C,D>` | `checkedApply(A a, B b)`
    `D` | `checkedApply(A a, B b, C c)`
    `default <Y,Z> Fn4<Y,Z,B,C,D>` | `compose(Fn2<? super Y,? super Z,? extends A> before)` Right-to-left composition between different arity functions.
    `default <Z> Fn3<Z,B,C,D>` | `contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `default <Z> Fn3<Z,B,C,D>` | `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 <E> Fn3<A,B,C,D>` | `discardR(Applicative<E,Fn1<A,?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `default Fn3<B,A,C,D>` | `flip()` Flip the order of the first two arguments.
    `static <A,B,C,D> Fn3<A,B,C,D>` | `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(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<A,B,C,D> fn)` Static factory method for coercing a lambda to an `Fn3`.
    `default Fn2<? super Product2<? extends A,? extends B>,C,D>` | `uncurry()` Returns an `Fn2` that takes the first two arguments as a ``Product2`<A, B>` and the third argument.
    `default <Z> Fn4<Z,A,B,C,D>` | `widen()` Widen this function's argument list by prepending an ignored argument of any type to the front.

    - ### Methods inherited from interface com.jnape.palatable.lambda.functions.Fn2

      `checkedApply, curried, curry, fn2, fromBiFunction, toBiFunction`

    - ### Methods inherited from interface com.jnape.palatable.lambda.functions.Fn1

      `andThen, carry, cartesian, censor, choose, cocartesian, diMap, diMapR, discardL, flatMap, fmap, fn1, fromFunction, lazyZip, listens, local, pure, pureFn1, thunk, toFunction, trampolineM, zip, zip`

    - ### Methods inherited from interface com.jnape.palatable.lambda.monad.Monad

      `join`

    - ### Methods inherited from interface com.jnape.palatable.lambda.functor.Functor

      `coerce`

- - ### Method Detail

    - #### checkedApply

          D checkedApply(A a,
                         B b,
                         C c)
                  throws Throwable

      Throws:
        `Throwable`

    - #### apply

          default D apply(A a,
                          B b,
                          C c)

      Invoke this function with the given arguments.
      Parameters:
        `a` - the first argument
        `b` - the second argument
        `c` - the third argument
      Returns:
        the result of the function application

    - #### checkedApply

          default Fn1<C,D> checkedApply(A a,
                                        B b)
                                 throws Throwable

      Specified by:
        `checkedApply` in interface `Fn2<A,B,Fn1<C,D>>`
      Throws:
        `Throwable`

    - #### widen

          default <Z> Fn4<Z,A,B,C,D> widen()

      Widen this function's argument list by prepending an ignored argument of any type to the front.
      Specified by:
        `widen` in interface `Fn1<A,Fn1<B,Fn1<C,D>>>`
      Specified by:
        `widen` in interface `Fn2<A,B,Fn1<C,D>>`
      Type Parameters:
        `Z` - the new first argument type
      Returns:
        the widened function

    - #### apply

          default Fn2<B,C,D> apply(A a)

      Partially apply this function by taking its first argument.
      Specified by:
        `apply` in interface `Fn1<A,Fn1<B,Fn1<C,D>>>`
      Specified by:
        `apply` in interface `Fn2<A,B,Fn1<C,D>>`
      Parameters:
        `a` - the first argument
      Returns:
        an `Fn2`<B, C, D>

    - #### apply

          default Fn1<C,D> apply(A a,
                                 B b)

      Partially apply this function by taking its first two arguments.
      Specified by:
        `apply` in interface `Fn2<A,B,Fn1<C,D>>`
      Parameters:
        `a` - the first argument
        `b` - the second argument
      Returns:
        an `Fn1`<C, D>

    - #### flip

          default Fn3<B,A,C,D> flip()

      Flip the order of the first two arguments.
      Specified by:
        `flip` in interface `Fn2<A,B,Fn1<C,D>>`
      Returns:
        an `Fn3`<B, A, C, D>

    - #### uncurry

          default Fn2<? super Product2<? extends A,? extends B>,C,D> uncurry()

      Returns an `Fn2` that takes the first two arguments as a ``Product2`<A, B>` and the third argument.
      Specified by:
        `uncurry` in interface `Fn2<A,B,Fn1<C,D>>`
      Returns:
        an `Fn2` taking a `Product2` and the third argument

    - #### discardR

          default <E> Fn3<A,B,C,D> discardR(Applicative<E,Fn1<A,?>> appB)

      Description copied from interface: `Fn2`
      Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`. This is generally useful for sequentially performing side-effects.
      Specified by:
        `discardR` in interface `Applicative<Fn1<B,Fn1<C,D>>,Fn1<A,?>>`
      Specified by:
        `discardR` in interface `Fn1<A,Fn1<B,Fn1<C,D>>>`
      Specified by:
        `discardR` in interface `Fn2<A,B,Fn1<C,D>>`
      Specified by:
        `discardR` in interface `Monad<Fn1<B,Fn1<C,D>>,Fn1<A,?>>`
      Specified by:
        `discardR` in interface `MonadReader<A,Fn1<B,Fn1<C,D>>,Fn1<A,?>>`
      Specified by:
        `discardR` in interface `MonadRec<Fn1<B,Fn1<C,D>>,Fn1<A,?>>`
      Specified by:
        `discardR` in interface `MonadWriter<A,Fn1<B,Fn1<C,D>>,Fn1<A,?>>`
      Type Parameters:
        `E` - the type of appB's parameter
      Parameters:
        `appB` - the other Applicative
      Returns:
        this Applicative

    - #### diMapL

          default <Z> Fn3<Z,B,C,D> diMapL(Fn1<? super Z,? extends A> fn)

      Description copied from interface: `Fn2`
      Contravariantly map over the argument to this function, producing a function that takes the new argument type, and produces the same result.
      Specified by:
        `diMapL` in interface `Cartesian<A,Fn1<B,Fn1<C,D>>,Fn1<?,?>>`
      Specified by:
        `diMapL` in interface `Cocartesian<A,Fn1<B,Fn1<C,D>>,Fn1<?,?>>`
      Specified by:
        `diMapL` in interface `Fn1<A,Fn1<B,Fn1<C,D>>>`
      Specified by:
        `diMapL` in interface `Fn2<A,B,Fn1<C,D>>`
      Specified by:
        `diMapL` in interface `Profunctor<A,Fn1<B,Fn1<C,D>>,Fn1<?,?>>`
      Type Parameters:
        `Z` - the new argument type
      Parameters:
        `fn` - the contravariant argument mapping function
      Returns:
        an `Fn1`<Z, B>

    - #### contraMap

          default <Z> Fn3<Z,B,C,D> contraMap(Fn1<? super Z,? extends A> fn)

      Description copied from interface: `Fn2`
      Contravariantly map `A <- B`.
      Specified by:
        `contraMap` in interface `Cartesian<A,Fn1<B,Fn1<C,D>>,Fn1<?,?>>`
      Specified by:
        `contraMap` in interface `Cocartesian<A,Fn1<B,Fn1<C,D>>,Fn1<?,?>>`
      Specified by:
        `contraMap` in interface `Contravariant<A,Profunctor<?,Fn1<B,Fn1<C,D>>,Fn1<?,?>>>`
      Specified by:
        `contraMap` in interface `Fn1<A,Fn1<B,Fn1<C,D>>>`
      Specified by:
        `contraMap` in interface `Fn2<A,B,Fn1<C,D>>`
      Specified by:
        `contraMap` in interface `Profunctor<A,Fn1<B,Fn1<C,D>>,Fn1<?,?>>`
      Type Parameters:
        `Z` - the new parameter type
      Parameters:
        `fn` - the mapping function
      Returns:
        the mapped Contravariant functor instance

    - #### compose

          default <Y,Z> Fn4<Y,Z,B,C,D> compose(Fn2<? super Y,? super Z,? extends A> before)

      Description copied from interface: `Fn2`
      Right-to-left composition between different arity functions. Preserves highest arity in the return type.
      Specified by:
        `compose` in interface `Fn1<A,Fn1<B,Fn1<C,D>>>`
      Specified by:
        `compose` in interface `Fn2<A,B,Fn1<C,D>>`
      Type Parameters:
        `Y` - the resulting function's first argument type
        `Z` - the resulting function's second argument type
      Parameters:
        `before` - the function to pass its return value to this function's input
      Returns:
        an `Fn2`<Y, Z, B>

    - #### fn3

          static <A,B,C,D> Fn3<A,B,C,D> fn3(Fn1<A,Fn2<B,C,D>> curriedFn1)

      Static factory method for wrapping a curried `Fn1` in an `Fn3`.
      Type Parameters:
        `A` - the first input argument type
        `B` - the second input argument type
        `C` - the third input argument type
        `D` - the output type
      Parameters:
        `curriedFn1` - the curried fn1 to adapt
      Returns:
        the `Fn3`

    - #### fn3

          static <A,B,C,D> Fn3<A,B,C,D> fn3(Fn2<A,B,Fn1<C,D>> curriedFn2)

      Static factory method for wrapping a curried `Fn2` in an `Fn3`.
      Type Parameters:
        `A` - the first input argument type
        `B` - the second input argument type
        `C` - the third input argument type
        `D` - the output type
      Parameters:
        `curriedFn2` - the curried fn2 to adapt
      Returns:
        the `Fn3`

    - #### fn3

          static <A,B,C,D> Fn3<A,B,C,D> fn3(Fn3<A,B,C,D> fn)

      Static factory method for coercing a lambda to an `Fn3`.
      Type Parameters:
        `A` - the first input argument type
        `B` - the second input argument type
        `C` - the third input argument type
        `D` - the output type
      Parameters:
        `fn` - the lambda to coerce
      Returns:
        the `Fn3`