de.caff.generics.function

## Interface Function9<R,P1,P2,P3,P4,P5,P6,P7,P8,P9>

- Type Parameters:
    `R` - return type
    `P1` - parameter type 1
    `P2` - parameter type 2
    `P3` - parameter type 3
    `P4` - parameter type 4
    `P5` - parameter type 5
    `P6` - parameter type 6
    `P7` - parameter type 7
    `P8` - parameter type 8
    `P9` - parameter type 9
  All Superinterfaces:
    java.util.function.Function<ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,R>, Function1<R,ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>>
  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 Function9<R,P1,P2,P3,P4,P5,P6,P7,P8,P9>
      extends Function1<R,ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>>

  Function with nine parameters.
  Author:
    Rammi
  See Also:
    `Function0`, `Function1`, `Function2`, `Function3`, `Function4`, `Function5`, `Function6`, `Function7`, `Function8`

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP> Function1<R,FP>` | `after1(java.util.function.Function<FP,FR> before)` Get a chained function which first applies the given function, then this one.
    `default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2> Function2<R,FP1,FP2>` | `after2(java.util.function.BiFunction<FP1,FP2,FR> before)` Get a chained function which first applies the given 2-parameter function, then this one.
    `default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2,FP3> Function3<R,FP1,FP2,FP3>` | `after3(Function3<FR,FP1,FP2,FP3> before)` Get a chained function which first applies the given 3-parameter function, then this one.
    `default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2,FP3,FP4,FP5> Function5<R,FP1,FP2,FP3,FP4,FP5>` | `after5(Function5<FR,FP1,FP2,FP3,FP4,FP5> before)` Get a chained function which first applies the given 5-parameter function, then this one.
    `default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2,FP3,FP4,FP5,FP6> Function6<R,FP1,FP2,FP3,FP4,FP5,FP6>` | `after6(Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before)` Get a chained function which first applies the given 6-parameter function, then this one.
    `default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2,FP3,FP4,FP5,FP6,FP7> Function7<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7>` | `after7(Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before)` Get a chained function which first applies the given 7-parameter function, then this one.
    `default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> Function8<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8>` | `after8(Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before)` Get a chained function which first applies the given 8-parameter function, then this one.
    `default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> Function9<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9>` | `after9(Function9<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> before)` Get a chained function which first applies the given 9-parameter function, then this one.
    `default <T> Function9<T,P1,P2,P3,P4,P5,P6,P7,P8,P9>` | `andThen(java.util.function.Function<? super R,? extends T> after)` Get a chained function which first applies this function and then the given function to the returned value.
    `default R` | `apply(ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9> tuple9)` Expand a tuple into the arguments of this function.
    `R` | `apply(P1 arg1, P2 arg2, P3 arg3, P4 arg4, P5 arg5, P6 arg6, P7 arg7, P8 arg8, P9 arg9)` Run the function.
    `default R` | `applyOrDefault(P1 arg1, P2 arg2, P3 arg3, P4 arg4, P5 arg5, P6 arg6, P7 arg7, P8 arg8, P9 arg9, R fallback)` Apply this function, but take care to create a fallback.
    `default Function8<R,P2,P3,P4,P5,P6,P7,P8,P9>` | `partial1(P1 argument)` Get a partially applied function.
    `default Function8<R,P1,P3,P4,P5,P6,P7,P8,P9>` | `partial2(P2 argument)` Get a partially applied function.
    `default Function8<R,P1,P2,P4,P5,P6,P7,P8,P9>` | `partial3(P3 argument)` Get a partially applied function.
    `default Function8<R,P1,P2,P3,P5,P6,P7,P8,P9>` | `partial4(P4 argument)` Get a partially applied function.
    `default Function8<R,P1,P2,P3,P4,P6,P7,P8,P9>` | `partial5(P5 argument)` Get a partially applied function.
    `default Function8<R,P1,P2,P3,P4,P5,P7,P8,P9>` | `partial6(P6 argument)` Get a partially applied function.
    `default Function8<R,P1,P2,P3,P4,P5,P6,P8,P9>` | `partial7(P7 argument)` Get a partially applied function.
    `default Function8<R,P1,P2,P3,P4,P5,P6,P7,P9>` | `partial8(P8 argument)` Get a partially applied function.
    `default Function8<R,P1,P2,P3,P4,P5,P6,P7,P8>` | `partial9(P9 argument)` Get a partially applied function.

    - ### Methods inherited from interface de.caff.generics.function.Function1

      `after, applyNonNull, applyOrDefault, fallback, fallback, from, from, nonFragile, nonFragile, nonFragileX, partial, withFallback`

    - ### Methods inherited from interface java.util.function.Function

      `compose, identity`

- - ### Method Detail

    - #### apply

          R apply(P1 arg1,
                  P2 arg2,
                  P3 arg3,
                  P4 arg4,
                  P5 arg5,
                  P6 arg6,
                  P7 arg7,
                  P8 arg8,
                  P9 arg9)

      Run the function.
      Parameters:
        `arg1` - function argument 1
        `arg2` - function argument 2
        `arg3` - function argument 3
        `arg4` - function argument 4
        `arg5` - function argument 5
        `arg6` - function argument 6
        `arg7` - function argument 7
        `arg8` - function argument 8
        `arg9` - function argument 9
      Returns:
        return value

    - #### apply

          default R apply(@NotNull
                          ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9> tuple9)

      Expand a tuple into the arguments of this function.
      Specified by:
        `apply` in interface `java.util.function.Function<ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,R>`
      Parameters:
        `tuple9` - tuple to expand
      Returns:
        the result of calling this function with the arguments set from the tuple

    - #### applyOrDefault

          @NotNull
          default R applyOrDefault(P1 arg1,
                                            P2 arg2,
                                            P3 arg3,
                                            P4 arg4,
                                            P5 arg5,
                                            P6 arg6,
                                            P7 arg7,
                                            P8 arg8,
                                            P9 arg9,
                                            @NotNull
                                            R fallback)

      Apply this function, but take care to create a fallback. Thiw will return the fallback when `apply(Object, Object, Object, Object, Object, Object, Object, Object, Object)` returns `null`.
      Parameters:
        `arg1` - first argument of this function
        `arg2` - second argument of this function
        `arg3` - third argument of this function
        `arg4` - fourth argument of this function
        `arg5` - fifth argument of this function
        `arg6` - sixth argument of this function
        `arg7` - seventh argument of this function
        `arg8` - eighth argument of this function
        `arg9` - ninth argument of this function
        `fallback` - fallback value returned if function returns `null`
      Returns:
        the non-null result of calling `apply(Object, Object, Object, Object, Object, Object, Object, Object, Object)`, or `fallback` if the result was `null`

    - #### partial1

          @NotNull
          default Function8<R,P2,P3,P4,P5,P6,P7,P8,P9> partial1(P1 argument)

      Get a partially applied function.
      Parameters:
        `argument` - value applied for first argument
      Returns:
        partially evaluated function

    - #### partial2

          @NotNull
          default Function8<R,P1,P3,P4,P5,P6,P7,P8,P9> partial2(P2 argument)

      Get a partially applied function.
      Parameters:
        `argument` - value applied for second argument
      Returns:
        partially evaluated function

    - #### partial3

          @NotNull
          default Function8<R,P1,P2,P4,P5,P6,P7,P8,P9> partial3(P3 argument)

      Get a partially applied function.
      Parameters:
        `argument` - value applied for third argument
      Returns:
        partially evaluated function

    - #### partial4

          @NotNull
          default Function8<R,P1,P2,P3,P5,P6,P7,P8,P9> partial4(P4 argument)

      Get a partially applied function.
      Parameters:
        `argument` - value applied for fourth argument
      Returns:
        partially evaluated function

    - #### partial5

          @NotNull
          default Function8<R,P1,P2,P3,P4,P6,P7,P8,P9> partial5(P5 argument)

      Get a partially applied function.
      Parameters:
        `argument` - value applied for fifth argument
      Returns:
        partially evaluated function

    - #### partial6

          @NotNull
          default Function8<R,P1,P2,P3,P4,P5,P7,P8,P9> partial6(P6 argument)

      Get a partially applied function.
      Parameters:
        `argument` - value applied for sixth argument
      Returns:
        partially evaluated function

    - #### partial7

          @NotNull
          default Function8<R,P1,P2,P3,P4,P5,P6,P8,P9> partial7(P7 argument)

      Get a partially applied function.
      Parameters:
        `argument` - value applied for seventh argument
      Returns:
        partially evaluated function

    - #### partial8

          @NotNull
          default Function8<R,P1,P2,P3,P4,P5,P6,P7,P9> partial8(P8 argument)

      Get a partially applied function.
      Parameters:
        `argument` - value applied for eighth argument
      Returns:
        partially evaluated function

    - #### partial9

          @NotNull
          default Function8<R,P1,P2,P3,P4,P5,P6,P7,P8> partial9(P9 argument)

      Get a partially applied function.
      Parameters:
        `argument` - value applied for eighth argument
      Returns:
        partially evaluated function

    - #### andThen

          @NotNull
          default <T> Function9<T,P1,P2,P3,P4,P5,P6,P7,P8,P9> andThen(@NotNull
                                                                               java.util.function.Function<? super R,? extends T> after)

      Get a chained function which first applies this function and then the given function to the returned value.
      Specified by:
        `andThen` in interface `java.util.function.Function<ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,R>`
      Specified by:
        `andThen` in interface `Function1<R,ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>>`
      Type Parameters:
        `T` - result type of returned function
      Parameters:
        `after` - function to apply after this one
      Returns:
        function chain

    - #### after1

          @NotNull
          default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP> Function1<R,FP> after1(@NotNull
                                                                                                                                                                                                java.util.function.Function<FP,FR> before)

      Get a chained function which first applies the given function, then this one. The given function has to return a `ITuple9` with matching parametric types which are applied in their order to this function.
      Type Parameters:
        `FR` - function `before`'s return type, has to be a 9-tuple with matching types
        `FP` - function `before`'s parameter type, same for returned function
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        function chain

    - #### after2

          @NotNull
          default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2> Function2<R,FP1,FP2> after2(@NotNull
                                                                                                                                                                                                          java.util.function.BiFunction<FP1,FP2,FR> before)

      Get a chained function which first applies the given 2-parameter function, then this one. The given function has to return a `ITuple9` with matching parametric types which are applied in their order to this function.
      Type Parameters:
        `FR` - function `before`'s return type, has to be a 9-tuple with matching types
        `FP1` - function `before`'s first parameter type, sane for returned function
        `FP2` - function `before`'s second parameter type, same for returned function
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        function chain

    - #### after3

          @NotNull
          default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2,FP3> Function3<R,FP1,FP2,FP3> after3(@NotNull
                                                                                                                                                                                                                  Function3<FR,FP1,FP2,FP3> before)

      Get a chained function which first applies the given 3-parameter function, then this one. The given function has to return a `ITuple9` with matching parametric types which are applied in their order to this function.
      Type Parameters:
        `FR` - function `before`'s return type, has to be a 9-tuple with matching types
        `FP1` - function `before`'s first parameter type, sane for returned function
        `FP2` - function `before`'s second parameter type, sane for returned function
        `FP3` - function `before`'s third parameter type, sane for returned function
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        function chain

    - #### after5

          @NotNull
          default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2,FP3,FP4,FP5> Function5<R,FP1,FP2,FP3,FP4,FP5> after5(@NotNull
                                                                                                                                                                                                                                  Function5<FR,FP1,FP2,FP3,FP4,FP5> before)

      Get a chained function which first applies the given 5-parameter function, then this one. The given function has to return a `ITuple9` with matching parametric types which are applied in their order to this function.
      Type Parameters:
        `FR` - function `before`'s return type, has to be a 9-tuple with matching types
        `FP1` - function `before`'s first parameter type, sane for returned function
        `FP2` - function `before`'s second parameter type, sane for returned function
        `FP3` - function `before`'s third parameter type, sane for returned function
        `FP4` - function `before`'s fourth parameter type, sane for returned function
        `FP5` - function `before`'s fifth parameter type, sane for returned function
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        function chain

    - #### after6

          @NotNull
          default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2,FP3,FP4,FP5,FP6> Function6<R,FP1,FP2,FP3,FP4,FP5,FP6> after6(@NotNull
                                                                                                                                                                                                                                          Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before)

      Get a chained function which first applies the given 6-parameter function, then this one. The given function has to return a `ITuple9` with matching parametric types which are applied in their order to this function.
      Type Parameters:
        `FR` - function `before`'s return type, has to be a 9-tuple with matching types
        `FP1` - function `before`'s first parameter type, sane for returned function
        `FP2` - function `before`'s second parameter type, sane for returned function
        `FP3` - function `before`'s third parameter type, sane for returned function
        `FP4` - function `before`'s fourth parameter type, sane for returned function
        `FP5` - function `before`'s fifth parameter type, sane for returned function
        `FP6` - function `before`'s sixth parameter type, sane for returned function
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        function chain

    - #### after7

          @NotNull
          default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2,FP3,FP4,FP5,FP6,FP7> Function7<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7> after7(@NotNull
                                                                                                                                                                                                                                                  Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before)

      Get a chained function which first applies the given 7-parameter function, then this one. The given function has to return a `ITuple9` with matching parametric types which are applied in their order to this function.
      Type Parameters:
        `FR` - function `before`'s return type, has to be a 9-tuple with matching types
        `FP1` - function `before`'s first parameter type, sane for returned function
        `FP2` - function `before`'s second parameter type, sane for returned function
        `FP3` - function `before`'s third parameter type, sane for returned function
        `FP4` - function `before`'s fourth parameter type, sane for returned function
        `FP5` - function `before`'s fifth parameter type, sane for returned function
        `FP6` - function `before`'s sixth parameter type, sane for returned function
        `FP7` - function `before`'s seventh parameter type, sane for returned function
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        function chain

    - #### after8

          @NotNull
          default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> Function8<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> after8(@NotNull
                                                                                                                                                                                                                                                          Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before)

      Get a chained function which first applies the given 8-parameter function, then this one. The given function has to return a `ITuple9` with matching parametric types which are applied in their order to this function.
      Type Parameters:
        `FR` - function `before`'s return type, has to be a 9-tuple with matching types
        `FP1` - function `before`'s first parameter type, sane for returned function
        `FP2` - function `before`'s second parameter type, sane for returned function
        `FP3` - function `before`'s third parameter type, sane for returned function
        `FP4` - function `before`'s fourth parameter type, sane for returned function
        `FP5` - function `before`'s fifth parameter type, sane for returned function
        `FP6` - function `before`'s sixth parameter type, sane for returned function
        `FP7` - function `before`'s seventh parameter type, sane for returned function
        `FP8` - function `before`'s seventh parameter type, sane for returned function
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        function chain

    - #### after9

          @NotNull
          default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> Function9<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> after9(@NotNull
                                                                                                                                                                                                                                                                  Function9<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> before)

      Get a chained function which first applies the given 9-parameter function, then this one. The given function has to return a `ITuple9` with matching parametric types which are applied in their order to this function.
      Type Parameters:
        `FR` - function `before`'s return type, has to be a 9-tuple with matching types
        `FP1` - function `before`'s first parameter type, sane for returned function
        `FP2` - function `before`'s second parameter type, sane for returned function
        `FP3` - function `before`'s third parameter type, sane for returned function
        `FP4` - function `before`'s fourth parameter type, sane for returned function
        `FP5` - function `before`'s fifth parameter type, sane for returned function
        `FP6` - function `before`'s sixth parameter type, sane for returned function
        `FP7` - function `before`'s seventh parameter type, sane for returned function
        `FP8` - function `before`'s seventh parameter type, sane for returned function
        `FP9` - function `before`'s ninth parameter type, sane for returned function
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        function chain