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

    • Method Summary

      All Methods Static Methods Instance Methods Abstract Methods Default Methods 
      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.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.functor.Functor

        coerce
    • Method Detail

      • checkedApply

        I checkedApply​(A a,
                       B b,
                       C c,
                       D d,
                       E e,
                       F f,
                       G g,
                       H h)
                throws java.lang.Throwable
        Throws:
        java.lang.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 java.lang.Throwable
        Specified by:
        checkedApply in interface Fn7<A,​B,​C,​D,​E,​F,​G,​H>
        Throws:
        java.lang.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
      • 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>
      • 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