Package com.jnape.palatable.lambda.functions

Interface Fn8<A,B,C,D,E,F,G,H,I>

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 eighth argument type
I - The return type
All Superinterfaces:
Applicative<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<A,?>>, Cartesian<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<?,?>>, Cocartesian<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<?,?>>, Contravariant<A,Profunctor<?,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<?,?>>>, Fn1<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>>, Fn2<A,B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>, Fn3<A,B,C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>, Fn4<A,B,C,D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>, Fn5<A,B,C,D,E,Fn1<F,Fn1<G,Fn1<H,I>>>>, Fn6<A,B,C,D,E,F,Fn1<G,Fn1<H,I>>>, Fn7<A,B,C,D,E,F,G,Fn1<H,I>>, Functor<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<A,?>>, Monad<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<A,?>>, MonadReader<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<A,?>>, MonadRec<Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<A,?>>, MonadWriter<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<A,?>>, Profunctor<A,Fn1<B,Fn1<C,Fn1<D,Fn1<E,Fn1<F,Fn1<G,Fn1<H,I>>>>>>>,Fn1<?,?>>
All Known Implementing Classes:
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 Fn8<A,B,C,D,E,F,G,H,I> extends Fn7<A,B,C,D,E,F,G,Fn1<H,I>>
A function taking eight arguments. Defined in terms of Fn7, so similarly auto-curried.
See Also:

  • Method Summary

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

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

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

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

    checkedApply, toBiFunction

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

    checkedApply

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

    checkedApply

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

    checkedApply

    Methods inherited from interface com.jnape.palatable.lambda.functions.Fn6

    checkedApply

    Methods inherited from interface com.jnape.palatable.lambda.functions.Fn7

    checkedApply, widen

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

    coerce

  • Method Details

    • checkedApply

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

    • apply

      default I apply(A a, B b, C c, D d, E e, F f, G g, H h)
      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
      h - the eighth argument
      Returns:
      the result of the function application

    • checkedApply

      default Fn1<H,I> checkedApply(A a, B b, C c, D d, E e, F f, G g) throws Throwable
      Specified by:
      checkedApply in interface Fn7<A,B,C,D,E,F,G,H>
      Throws:
      Throwable

    • apply

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

    • apply

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

    • apply

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

    • apply

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

    • apply

      default Fn3<F,G,H,I> 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,F>
      Specified by:
      apply in interface Fn6<A,B,C,D,E,F,G>
      Specified by:
      apply in interface Fn7<A,B,C,D,E,F,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 Fn3 that takes the remaining arguments and returns the result

    • apply

      default Fn2<G,H,I> 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,G>
      Specified by:
      apply in interface Fn7<A,B,C,D,E,F,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 Fn2 that takes the remaining arguments and returns the result

    • apply

      default Fn1<H,I> 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.
      Specified by:
      apply in interface Fn7<A,B,C,D,E,F,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
      g - the seventh argument
      Returns:
      an Fn1 that takes the remaining argument and returns the result

    • flip

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

    • uncurry

      default Fn7<? super Product2<? extends A,? extends B>,C,D,E,F,G,H,I> uncurry()
      Returns an Fn7 that takes the first two arguments as a Product2<A, B> and the remaining arguments.
      Specified by:
      uncurry in interface Fn2<A,B,C>
      Specified by:
      uncurry in interface Fn3<A,B,C,D>
      Specified by:
      uncurry in interface Fn4<A,B,C,D,E>
      Specified by:
      uncurry in interface Fn5<A,B,C,D,E,F>
      Specified by:
      uncurry in interface Fn6<A,B,C,D,E,F,G>
      Specified by:
      uncurry in interface Fn7<A,B,C,D,E,F,G,H>
      Returns:
      an Fn7 taking a Product2 and the remaining arguments

    • discardR

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

    • diMapL

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

    • contraMap

      default <Z> Fn8<Z,B,C,D,E,F,G,H,I> contraMap(Fn1<? super Z,? extends A> fn)
      Description copied from interface: Fn2
      Contravariantly map A <- B.
      Specified by:
      contraMap in interface Cartesian<A,B,C>
      Specified by:
      contraMap in interface Cocartesian<A,B,C>
      Specified by:
      contraMap in interface Contravariant<A,B>
      Specified by:
      contraMap in interface Fn1<A,B>
      Specified by:
      contraMap in interface Fn2<A,B,C>
      Specified by:
      contraMap in interface Fn3<A,B,C,D>
      Specified by:
      contraMap in interface Fn4<A,B,C,D,E>
      Specified by:
      contraMap in interface Fn5<A,B,C,D,E,F>
      Specified by:
      contraMap in interface Fn6<A,B,C,D,E,F,G>
      Specified by:
      contraMap in interface Fn7<A,B,C,D,E,F,G,H>
      Specified by:
      contraMap in interface Profunctor<A,B,C>
      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,Fn1<H,I>> 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,B>
      Specified by:
      compose in interface Fn2<A,B,C>
      Specified by:
      compose in interface Fn3<A,B,C,D>
      Specified by:
      compose in interface Fn4<A,B,C,D,E>
      Specified by:
      compose in interface Fn5<A,B,C,D,E,F>
      Specified by:
      compose in interface Fn6<A,B,C,D,E,F,G>
      Specified by:
      compose in interface Fn7<A,B,C,D,E,F,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>

    • fn8

      static <A, B, C, D, E, F, G, H, I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn1<A,Fn7<B,C,D,E,F,G,H,I>> curriedFn1)
      Static factory method for wrapping a curried Fn1 in an Fn8.
      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 eighth input argument type
      I - the output type
      Parameters:
      curriedFn1 - the curried fn1 to adapt
      Returns:
      the Fn8

    • fn8

      static <A, B, C, D, E, F, G, H, I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn2<A,B,Fn6<C,D,E,F,G,H,I>> curriedFn2)
      Static factory method for wrapping a curried Fn2 in an Fn8.
      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 eighth input argument type
      I - the output type
      Parameters:
      curriedFn2 - the curried fn2 to adapt
      Returns:
      the Fn8

    • fn8

      static <A, B, C, D, E, F, G, H, I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn3<A,B,C,Fn5<D,E,F,G,H,I>> curriedFn3)
      Static factory method for wrapping a curried Fn3 in an Fn8.
      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 eighth input argument type
      I - the output type
      Parameters:
      curriedFn3 - the curried fn3 to adapt
      Returns:
      the Fn8

    • fn8

      static <A, B, C, D, E, F, G, H, I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn4<A,B,C,D,Fn4<E,F,G,H,I>> curriedFn4)
      Static factory method for wrapping a curried Fn4 in an Fn8.
      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 eighth input argument type
      I - the output type
      Parameters:
      curriedFn4 - the curried fn4 to adapt
      Returns:
      the Fn8

    • fn8

      static <A, B, C, D, E, F, G, H, I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn5<A,B,C,D,E,Fn3<F,G,H,I>> curriedFn5)
      Static factory method for wrapping a curried Fn5 in an Fn8.
      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 eighth input argument type
      I - the output type
      Parameters:
      curriedFn5 - the curried fn5 to adapt
      Returns:
      the Fn8

    • fn8

      static <A, B, C, D, E, F, G, H, I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn6<A,B,C,D,E,F,Fn2<G,H,I>> curriedFn6)
      Static factory method for wrapping a curried Fn6 in an Fn8.
      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 eighth input argument type
      I - the output type
      Parameters:
      curriedFn6 - the curried fn6 to adapt
      Returns:
      the Fn8

    • fn8

      static <A, B, C, D, E, F, G, H, I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn7<A,B,C,D,E,F,G,Fn1<H,I>> curriedFn7)
      Static factory method for wrapping a curried Fn7 in an Fn8.
      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 eighth input argument type
      I - the output type
      Parameters:
      curriedFn7 - the curried fn7 to adapt
      Returns:
      the Fn8

    • fn8

      static <A, B, C, D, E, F, G, H, I> Fn8<A,B,C,D,E,F,G,H,I> fn8(Fn8<A,B,C,D,E,F,G,H,I> fn)
      Static factory method for coercing a lambda to an Fn8.
      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 eighth input argument type
      I - the output type
      Parameters:
      fn - the lambda to coerce
      Returns:
      the Fn8