com.jnape.palatable.lambda.functions

## Interface Fn7<A,B,C,D,E,F,G,H>

- Type Parameters:
    `A` - The first argument type
    `B` - The second argument type
    `C` - The third argument type
    `D` - The fourth argument type
    `E` - The fifth argument type
    `F` - The sixth argument type
    `G` - The seventh argument type
    `H` - The return type
  All Superinterfaces:
    Applicative<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<A,?>>, Cartesian<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<?,?>>, Cocartesian<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<?,?>>, Contravariant<A,Profunctor<?,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<?,?>>>, Fn1<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>>, Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>, Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>, Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,H>>>>, Fn5<A,B,C,D,E,Fn1<F,Fn1<G,H>>>, Fn6<A,B,C,D,E,F,Fn1<G,H>>, Functor<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<A,?>>, Monad<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<A,?>>, MonadReader<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<A,?>>, MonadRec<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<A,?>>, MonadWriter<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<A,?>>, Profunctor<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<?,?>>
  All Known Subinterfaces:
    Fn8<A,B,C,D,E,F,G,H,I>
  All Known Implementing Classes:
    LiftA6, LiftA7
  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 Fn7<A,B,C,D,E,F,G,H>
      extends Fn6<A,B,C,D,E,F,Fn1<G,H>>

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

- - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `default Fn6<B,C,D,E,F,G,H>` | `apply(A a)` Partially apply this function by taking its first argument.
    `default Fn5<C,D,E,F,G,H>` | `apply(A a, B b)` Partially apply this function by taking its first two arguments.
    `default Fn4<D,E,F,G,H>` | `apply(A a, B b, C c)` Partially apply this function by taking its first three arguments.
    `default Fn3<E,F,G,H>` | `apply(A a, B b, C c, D d)` Partially apply this function by taking its first four arguments.
    `default Fn2<F,G,H>` | `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>` | `apply(A a, B b, C c, D d, E e, F f)` Partially apply this function by taking its first six arguments.
    `default H` | `apply(A a, B b, C c, D d, E e, F f, G g)` Invoke this function with the given arguments.
    `default Fn1<G,H>` | `checkedApply(A a, B b, C c, D d, E e, F f)`
    `H` | `checkedApply(A a, B b, C c, D d, E e, F f, G g)`
    `default <Y,Z> Fn8<Y,Z,B,C,D,E,F,G,H>` | `compose(Fn2<? super Y,? super Z,? extends A> before)` Right-to-left composition between different arity functions.
    `default <Z> Fn7<Z,B,C,D,E,F,G,H>` | `contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `default <Z> Fn7<Z,B,C,D,E,F,G,H>` | `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 <I> Fn7<A,B,C,D,E,F,G,H>` | `discardR(Applicative<I,Fn1<A,?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `default Fn7<B,A,C,D,E,F,G,H>` | `flip()` Flip the order of the first two arguments.
    `static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H>` | `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> Fn7<A,B,C,D,E,F,G,H>` | `fn7(Fn2<A,B,Fn5<C,D,E,F,G,H>> curriedFn2)` Static factory method for wrapping a curried `Fn2` in an `Fn7`.
    `static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H>` | `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> Fn7<A,B,C,D,E,F,G,H>` | `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> Fn7<A,B,C,D,E,F,G,H>` | `fn7(Fn5<A,B,C,D,E,Fn2<F,G,H>> curriedFn5)` Static factory method for wrapping a curried `Fn5` in an `Fn7`.
    `static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H>` | `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> Fn7<A,B,C,D,E,F,G,H>` | `fn7(Fn7<A,B,C,D,E,F,G,H> fn)` Static factory method for coercing a lambda to an `Fn7`.
    `default Fn6<? super Product2<? extends A,? extends B>,C,D,E,F,G,H>` | `uncurry()` Returns an `Fn6` that takes the first two arguments as a ``Product2`<A, B>` and the remaining arguments.
    `default <Z> Fn8<Z,A,B,C,D,E,F,G,H>` | `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.Fn6

      `checkedApply, fn6, fn6, fn6, fn6, fn6, fn6`

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

      `checkedApply, fn5, fn5, fn5, fn5, fn5`

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

      `checkedApply, fn4, fn4, fn4, fn4`

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

      `checkedApply, fn3, fn3, fn3`

    - ### 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

          H checkedApply(A a,
                         B b,
                         C c,
                         D d,
                         E e,
                         F f,
                         G g)
                  throws Throwable

      Throws:
        `Throwable`

    - #### apply

          default H apply(A a,
                          B b,
                          C c,
                          D d,
                          E e,
                          F f,
                          G g)

      Invoke this function with the given arguments.
      Parameters:
        `a` - the first argument
        `b` - the second argument
        `c` - the third argument
        `d` - the fourth argument
        `e` - the fifth argument
        `f` - the sixth argument
        `g` - the seventh argument
      Returns:
        the result of the function application

    - #### checkedApply

          default Fn1<G,H> checkedApply(A a,
                                        B b,
                                        C c,
                                        D d,
                                        E e,
                                        F f)
                                 throws Throwable

      Specified by:
        `checkedApply` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      Throws:
        `Throwable`

    - #### widen

          default <Z> Fn8<Z,A,B,C,D,E,F,G,H> 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,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>>`
      Specified by:
        `widen` in interface `Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>`
      Specified by:
        `widen` in interface `Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>`
      Specified by:
        `widen` in interface `Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,H>>>>`
      Specified by:
        `widen` in interface `Fn5<A,B,C,D,E,Fn1<F,Fn1<G,H>>>`
      Specified by:
        `widen` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      Type Parameters:
        `Z` - the new first argument type
      Returns:
        the widened function

    - #### apply

          default Fn6<B,C,D,E,F,G,H> apply(A a)

      Partially apply this function by taking its first argument.
      Specified by:
        `apply` in interface `Fn1<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>>`
      Specified by:
        `apply` in interface `Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>`
      Specified by:
        `apply` in interface `Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>`
      Specified by:
        `apply` in interface `Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,H>>>>`
      Specified by:
        `apply` in interface `Fn5<A,B,C,D,E,Fn1<F,Fn1<G,H>>>`
      Specified by:
        `apply` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      Parameters:
        `a` - the first argument
      Returns:
        an `Fn6` that takes the remaining arguments and returns the result

    - #### apply

          default Fn5<C,D,E,F,G,H> 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,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>`
      Specified by:
        `apply` in interface `Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>`
      Specified by:
        `apply` in interface `Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,H>>>>`
      Specified by:
        `apply` in interface `Fn5<A,B,C,D,E,Fn1<F,Fn1<G,H>>>`
      Specified by:
        `apply` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      Parameters:
        `a` - the first argument
        `b` - the second argument
      Returns:
        an `Fn5` that takes the remaining arguments and returns the result

    - #### apply

          default Fn4<D,E,F,G,H> apply(A a,
                                       B b,
                                       C c)

      Partially apply this function by taking its first three arguments.
      Specified by:
        `apply` in interface `Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>`
      Specified by:
        `apply` in interface `Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,H>>>>`
      Specified by:
        `apply` in interface `Fn5<A,B,C,D,E,Fn1<F,Fn1<G,H>>>`
      Specified by:
        `apply` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      Parameters:
        `a` - the first argument
        `b` - the second argument
        `c` - the third argument
      Returns:
        an `Fn4` that takes remaining arguments and returns the result

    - #### apply

          default Fn3<E,F,G,H> apply(A a,
                                     B b,
                                     C c,
                                     D d)

      Partially apply this function by taking its first four arguments.
      Specified by:
        `apply` in interface `Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,H>>>>`
      Specified by:
        `apply` in interface `Fn5<A,B,C,D,E,Fn1<F,Fn1<G,H>>>`
      Specified by:
        `apply` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      Parameters:
        `a` - the first argument
        `b` - the second argument
        `c` - the third argument
        `d` - the fourth argument
      Returns:
        an `Fn3` that takes the remaining arguments and returns the result

    - #### apply

          default Fn2<F,G,H> apply(A a,
                                   B b,
                                   C c,
                                   D d,
                                   E e)

      Partially apply this function by taking its first five arguments.
      Specified by:
        `apply` in interface `Fn5<A,B,C,D,E,Fn1<F,Fn1<G,H>>>`
      Specified by:
        `apply` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      Parameters:
        `a` - the first argument
        `b` - the second argument
        `c` - the third argument
        `d` - the fourth argument
        `e` - the fifth argument
      Returns:
        an `Fn2` that takes the remaining arguments and returns the result

    - #### apply

          default Fn1<G,H> apply(A a,
                                 B b,
                                 C c,
                                 D d,
                                 E e,
                                 F f)

      Partially apply this function by taking its first six arguments.
      Specified by:
        `apply` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      Parameters:
        `a` - the first argument
        `b` - the second argument
        `c` - the third argument
        `d` - the fourth argument
        `e` - the fifth argument
        `f` - the sixth argument
      Returns:
        an `Fn1` that takes the remaining argument and returns the result

    - #### flip

          default Fn7<B,A,C,D,E,F,G,H> flip()

      Flip the order of the first two arguments.
      Specified by:
        `flip` in interface `Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>`
      Specified by:
        `flip` in interface `Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>`
      Specified by:
        `flip` in interface `Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,H>>>>`
      Specified by:
        `flip` in interface `Fn5<A,B,C,D,E,Fn1<F,Fn1<G,H>>>`
      Specified by:
        `flip` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      Returns:
        an `Fn7` that takes the first and second arguments in reversed order

    - #### uncurry

          default Fn6<? super Product2<? extends A,? extends B>,C,D,E,F,G,H> uncurry()

      Returns an `Fn6` that takes the first two arguments as a ``Product2`<A, B>` and the remaining arguments.
      Specified by:
        `uncurry` in interface `Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>`
      Specified by:
        `uncurry` in interface `Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>`
      Specified by:
        `uncurry` in interface `Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,H>>>>`
      Specified by:
        `uncurry` in interface `Fn5<A,B,C,D,E,Fn1<F,Fn1<G,H>>>`
      Specified by:
        `uncurry` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      Returns:
        an `Fn6` taking a `Product2` and the remaining arguments

    - #### discardR

          default <I> Fn7<A,B,C,D,E,F,G,H> discardR(Applicative<I,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,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<A,?>>`
      Specified by:
        `discardR` in interface `Fn1<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>>`
      Specified by:
        `discardR` in interface `Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>`
      Specified by:
        `discardR` in interface `Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>`
      Specified by:
        `discardR` in interface `Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,H>>>>`
      Specified by:
        `discardR` in interface `Fn5<A,B,C,D,E,Fn1<F,Fn1<G,H>>>`
      Specified by:
        `discardR` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      Specified by:
        `discardR` in interface `Monad<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<A,?>>`
      Specified by:
        `discardR` in interface `MonadReader<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<A,?>>`
      Specified by:
        `discardR` in interface `MonadRec<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<A,?>>`
      Specified by:
        `discardR` in interface `MonadWriter<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<A,?>>`
      Type Parameters:
        `I` - the type of appB's parameter
      Parameters:
        `appB` - the other Applicative
      Returns:
        this Applicative

    - #### diMapL

          default <Z> Fn7<Z,B,C,D,E,F,G,H> 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,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<?,?>>`
      Specified by:
        `diMapL` in interface `Cocartesian<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<?,?>>`
      Specified by:
        `diMapL` in interface `Fn1<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>>`
      Specified by:
        `diMapL` in interface `Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>`
      Specified by:
        `diMapL` in interface `Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>`
      Specified by:
        `diMapL` in interface `Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,H>>>>`
      Specified by:
        `diMapL` in interface `Fn5<A,B,C,D,E,Fn1<F,Fn1<G,H>>>`
      Specified by:
        `diMapL` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      Specified by:
        `diMapL` in interface `Profunctor<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<?,?>>`
      Type Parameters:
        `Z` - the new argument type
      Parameters:
        `fn` - the contravariant argument mapping function
      Returns:
        an `Fn1`<Z, B>

    - #### contraMap

          default <Z> Fn7<Z,B,C,D,E,F,G,H> 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,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<?,?>>`
      Specified by:
        `contraMap` in interface `Cocartesian<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<?,?>>`
      Specified by:
        `contraMap` in interface `Contravariant<A,Profunctor<?,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<?,?>>>`
      Specified by:
        `contraMap` in interface `Fn1<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>>`
      Specified by:
        `contraMap` in interface `Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>`
      Specified by:
        `contraMap` in interface `Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>`
      Specified by:
        `contraMap` in interface `Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,H>>>>`
      Specified by:
        `contraMap` in interface `Fn5<A,B,C,D,E,Fn1<F,Fn1<G,H>>>`
      Specified by:
        `contraMap` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      Specified by:
        `contraMap` in interface `Profunctor<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>,Fn1<?,?>>`
      Type Parameters:
        `Z` - the new parameter type
      Parameters:
        `fn` - the mapping function
      Returns:
        the mapped Contravariant functor instance

    - #### compose

          default <Y,Z> Fn8<Y,Z,B,C,D,E,F,G,H> 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,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>>`
      Specified by:
        `compose` in interface `Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>>`
      Specified by:
        `compose` in interface `Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,H>>>>>`
      Specified by:
        `compose` in interface `Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,H>>>>`
      Specified by:
        `compose` in interface `Fn5<A,B,C,D,E,Fn1<F,Fn1<G,H>>>`
      Specified by:
        `compose` in interface `Fn6<A,B,C,D,E,F,Fn1<G,H>>`
      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>

    - #### fn7

          static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H> fn7(Fn1<A,Fn6<B,C,D,E,F,G,H>> curriedFn1)

      Static factory method for wrapping a curried `Fn1` in an `Fn7`.
      Type Parameters:
        `A` - the first input argument type
        `B` - the second input argument type
        `C` - the third input argument type
        `D` - the fourth input argument type
        `E` - the fifth input argument type
        `F` - the sixth input argument type
        `G` - the seventh input argument type
        `H` - the output type
      Parameters:
        `curriedFn1` - the curried fn1 to adapt
      Returns:
        the `Fn7`

    - #### fn7

          static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H> fn7(Fn2<A,B,Fn5<C,D,E,F,G,H>> curriedFn2)

      Static factory method for wrapping a curried `Fn2` in an `Fn7`.
      Type Parameters:
        `A` - the first input argument type
        `B` - the second input argument type
        `C` - the third input argument type
        `D` - the fourth input argument type
        `E` - the fifth input argument type
        `F` - the sixth input argument type
        `G` - the seventh input argument type
        `H` - the output type
      Parameters:
        `curriedFn2` - the curried fn2 to adapt
      Returns:
        the `Fn7`

    - #### fn7

          static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H> fn7(Fn3<A,B,C,Fn4<D,E,F,G,H>> curriedFn3)

      Static factory method for wrapping a curried `Fn3` in an `Fn7`.
      Type Parameters:
        `A` - the first input argument type
        `B` - the second input argument type
        `C` - the third input argument type
        `D` - the fourth input argument type
        `E` - the fifth input argument type
        `F` - the sixth input argument type
        `G` - the seventh input argument type
        `H` - the output type
      Parameters:
        `curriedFn3` - the curried fn3 to adapt
      Returns:
        the `Fn7`

    - #### fn7

          static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H> fn7(Fn4<A,B,C,D,Fn3<E,F,G,H>> curriedFn4)

      Static factory method for wrapping a curried `Fn4` in an `Fn7`.
      Type Parameters:
        `A` - the first input argument type
        `B` - the second input argument type
        `C` - the third input argument type
        `D` - the fourth input argument type
        `E` - the fifth input argument type
        `F` - the sixth input argument type
        `G` - the seventh input argument type
        `H` - the output type
      Parameters:
        `curriedFn4` - the curried fn4 to adapt
      Returns:
        the `Fn7`

    - #### fn7

          static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H> fn7(Fn5<A,B,C,D,E,Fn2<F,G,H>> curriedFn5)

      Static factory method for wrapping a curried `Fn5` in an `Fn7`.
      Type Parameters:
        `A` - the first input argument type
        `B` - the second input argument type
        `C` - the third input argument type
        `D` - the fourth input argument type
        `E` - the fifth input argument type
        `F` - the sixth input argument type
        `G` - the seventh input argument type
        `H` - the output type
      Parameters:
        `curriedFn5` - the curried fn4 to adapt
      Returns:
        the `Fn7`

    - #### fn7

          static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H> fn7(Fn6<A,B,C,D,E,F,Fn1<G,H>> curriedFn6)

      Static factory method for wrapping a curried `Fn6` in an `Fn7`.
      Type Parameters:
        `A` - the first input argument type
        `B` - the second input argument type
        `C` - the third input argument type
        `D` - the fourth input argument type
        `E` - the fifth input argument type
        `F` - the sixth input argument type
        `G` - the seventh input argument type
        `H` - the output type
      Parameters:
        `curriedFn6` - the curried fn4 to adapt
      Returns:
        the `Fn7`

    - #### fn7

          static <A,B,C,D,E,F,G,H> Fn7<A,B,C,D,E,F,G,H> fn7(Fn7<A,B,C,D,E,F,G,H> fn)

      Static factory method for coercing a lambda to an `Fn7`.
      Type Parameters:
        `A` - the first input argument type
        `B` - the second input argument type
        `C` - the third input argument type
        `D` - the fourth input argument type
        `E` - the fifth input argument type
        `F` - the sixth input argument type
        `G` - the seventh input argument type
        `H` - the output type
      Parameters:
        `fn` - the lambda to coerce
      Returns:
        the `Fn7`