de.caff.generics.function

## Interface Function4<R,P1,P2,P3,P4>

- Type Parameters:
    `R` - return type
    `P1` - parameter type 1
    `P2` - parameter type 2
    `P3` - parameter type 3
    `P4` - parameter type 4
  All Superinterfaces:
    java.util.function.Function<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,R>, Function1<R,ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>
  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 Function4<R,P1,P2,P3,P4>
      extends Function1<R,ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

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

- - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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> Function4<T,P1,P2,P3,P4>` | `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(ITuple4<? extends P1,? extends P2,? extends P3,? extends P4> tuple4)` Expand a tuple into the arguments of this function.
    `R` | `apply(P1 arg1, P2 arg2, P3 arg3, P4 arg4)` Run the function.
    `default R` | `applyOrDefault(P1 arg1, P2 arg2, P3 arg3, P4 arg4, R fallback)` Apply this function, but take care to create a fallback.
    `static <E extends java.lang.Exception,RR,PP1,PP2,PP3,PP4> Function4<RR,PP1,PP2,PP3,PP4>` | `nonFragile(FragileFunction4<? extends RR,E,? super PP1,? super PP2,? super PP3,? super PP4> fragileFunction)` Convert a 4-argument function which might throw a checked exception into one which does throw an unchecked exception.
    `static <E extends java.lang.Exception,RR,PP1,PP2,PP3,PP4> Function4<RR,PP1,PP2,PP3,PP4>` | `nonFragile(FragileFunction4<? extends RR,E,? super PP1,? super PP2,? super PP3,? super PP4> fragileFunction, RR fallback)` Convert a 4-argument function which might throw a checked exception into one which will return a default value instead of throwing an exception.
    `static <E extends java.lang.Exception,RR,PP1,PP2,PP3,PP4> Function4<RR,PP1,PP2,PP3,PP4>` | `nonFragileX(FragileFunction4<? extends RR,E,? super PP1,? super PP2,? super PP3,? super PP4> fragileFunction, Function5<? extends RR,? super E,? super PP1,? super PP2,? super PP3,? super PP4> exceptionHandler)` Convert a 4-argument function which might throw a checked exception into one for which you can decide what happens with the exception.
    `default Function3<R,P2,P3,P4>` | `partial1(P1 argument)` Get a partially applied function.
    `default Function3<R,P1,P3,P4>` | `partial2(P2 argument)` Get a partially applied function.
    `default Function3<R,P1,P2,P4>` | `partial3(P3 argument)` Get a partially applied function.
    `default Function3<R,P1,P2,P3>` | `partial4(P4 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)

      Run the function.
      Parameters:
        `arg1` - function argument 1
        `arg2` - function argument 2
        `arg3` - function argument 3
        `arg4` - function argument 4
      Returns:
        return value

    - #### apply

          default R apply(@NotNull
                          ITuple4<? extends P1,? extends P2,? extends P3,? extends P4> tuple4)

      Expand a tuple into the arguments of this function.
      Specified by:
        `apply` in interface `java.util.function.Function<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,R>`
      Parameters:
        `tuple4` - 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,
                                            @NotNull
                                            R fallback)

      Apply this function, but take care to create a fallback. Thiw will return the fallback when `apply(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
        `fallback` - fallback value returned if function returns `null`
      Returns:
        the non-null result of calling `apply(Object, Object, Object, Object)`, or `fallback` if the result was `null`

    - #### partial1

          @NotNull
          default Function3<R,P2,P3,P4> partial1(P1 argument)

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

    - #### partial2

          @NotNull
          default Function3<R,P1,P3,P4> partial2(P2 argument)

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

    - #### partial3

          @NotNull
          default Function3<R,P1,P2,P4> partial3(P3 argument)

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

    - #### partial4

          @NotNull
          default Function3<R,P1,P2,P3> partial4(P4 argument)

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

    - #### andThen

          @NotNull
          default <T> Function4<T,P1,P2,P3,P4> 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<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,R>`
      Specified by:
        `andThen` in interface `Function1<R,ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>`
      Type Parameters:
        `T` - result type of returned function
      Parameters:
        `after` - function to apply after this one
      Returns:
        function chain

    - #### after1

          @NotNull
          default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 `ITuple4` 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 4-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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 `ITuple4` 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 4-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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 `ITuple4` 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 4-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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 `ITuple4` 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 4-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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 `ITuple4` 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 4-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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 `ITuple4` 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 4-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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 `ITuple4` 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 4-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 ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,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 `ITuple4` 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 4-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

    - #### nonFragile

          @NotNull
          static <E extends java.lang.Exception,RR,PP1,PP2,PP3,PP4> Function4<RR,PP1,PP2,PP3,PP4> nonFragile(@NotNull
                                                                                                                      FragileFunction4<? extends RR,E,? super PP1,? super PP2,? super PP3,? super PP4> fragileFunction)

      Convert a 4-argument function which might throw a checked exception into one which does throw an unchecked exception. The returned function will instead throw an unchecked `WrappedFragileException` for any checked exception thrown during `apply(Object, Object, Object, Object)`.
      Type Parameters:
        `E` - exception type
        `RR` - result type of incoming and outgoing function.
        `PP1` - type of first parameter of returned functions
        `PP2` - type of second parameter of returned functions
        `PP3` - type of third parameter of returned functions
        `PP4` - type of fourth parameter of returned functions
      Parameters:
        `fragileFunction` - function throwing a checked exception
      Returns:
        non-fragile function

    - #### nonFragile

          @NotNull
          static <E extends java.lang.Exception,RR,PP1,PP2,PP3,PP4> Function4<RR,PP1,PP2,PP3,PP4> nonFragile(@NotNull
                                                                                                                      FragileFunction4<? extends RR,E,? super PP1,? super PP2,? super PP3,? super PP4> fragileFunction,
                                                                                                                      RR fallback)

      Convert a 4-argument function which might throw a checked exception into one which will return a default value instead of throwing an exception. Please note that the exception is lost in this case.
      Type Parameters:
        `E` - exception type
        `RR` - result type of incoming and outgoing function.
        `PP1` - type of first parameter of returned functions
        `PP2` - type of second parameter of returned functions
        `PP3` - type of third parameter of returned functions
        `PP4` - type of fourth parameter of returned functions
      Parameters:
        `fragileFunction` - function throwing a checked exception
        `fallback` - fallback returned when `fragileFunction` has thrown an exception
      Returns:
        non-fragile function

    - #### nonFragileX

          @NotNull
          static <E extends java.lang.Exception,RR,PP1,PP2,PP3,PP4> Function4<RR,PP1,PP2,PP3,PP4> nonFragileX(@NotNull
                                                                                                                       FragileFunction4<? extends RR,E,? super PP1,? super PP2,? super PP3,? super PP4> fragileFunction,
                                                                                                                       @NotNull
                                                                                                                       Function5<? extends RR,? super E,? super PP1,? super PP2,? super PP3,? super PP4> exceptionHandler)

      Convert a 4-argument function which might throw a checked exception into one for which you can decide what happens with the exception. The exception handler allows
      - throw an unchecked exception instead (compare `Function1.nonFragile(FragileFunction1)`)
      - provide a fallback value (compare `Function1.nonFragile(FragileFunction1, Object)`)
      - include logging in one of the above
      - and more...
      Type Parameters:
        `E` - exception type
        `RR` - result type of incoming and outgoing function.
        `PP1` - type of first parameter of returned functions
        `PP2` - type of second parameter of returned functions
        `PP3` - type of third parameter of returned functions
        `PP4` - type of fourth parameter of returned functions
      Parameters:
        `fragileFunction` - function throwing a checked exception
        `exceptionHandler` - exception handler. Its return value will be used as return value of the returned function.
      Returns:
        non-fragile function