de.caff.generics.function

## Interface Function3<R,P1,P2,P3>

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

  Function with three parameters.
  Author:
    Rammi
  See Also:
    `Function0`, `Function1`, `Function2`, `Function4`, `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 ITuple3<? extends P1,? extends P2,? extends P3>,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 ITuple3<? extends P1,? extends P2,? extends P3>,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 ITuple3<? extends P1,? extends P2,? extends P3>,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 ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4> Function4<R,FP1,FP2,FP3,FP4>` | `after4(Function4<FR,FP1,FP2,FP3,FP4> before)` Get a chained function which first applies the given 4-parameter function, then this one.
    `default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,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 ITuple3<? extends P1,? extends P2,? extends P3>,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 ITuple3<? extends P1,? extends P2,? extends P3>,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 ITuple3<? extends P1,? extends P2,? extends P3>,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 ITuple3<? extends P1,? extends P2,? extends P3>,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> Function3<T,P1,P2,P3>` | `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(ITuple3<? extends P1,? extends P2,? extends P3> tuple3)` Expand a tuple into the arguments of this function.
    `R` | `apply(P1 arg1, P2 arg2, P3 arg3)` Run the function.
    `default R` | `applyOrDefault(P1 arg1, P2 arg2, P3 arg3, R fallback)` Apply this function, but take care to create a fallback.
    `static <E extends java.lang.Exception,RR,PP1,PP2,PP3> Function3<RR,PP1,PP2,PP3>` | `nonFragile(FragileFunction3<? extends RR,E,? super PP1,? super PP2,? super PP3> fragileFunction)` Convert a 3-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> Function3<RR,PP1,PP2,PP3>` | `nonFragile(FragileFunction3<? extends RR,E,? super PP1,? super PP2,? super PP3> fragileFunction, RR fallback)` Convert a 3-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> Function3<RR,PP1,PP2,PP3>` | `nonFragileX(FragileFunction3<? extends RR,E,? super PP1,? super PP2,? super PP3> fragileFunction, Function4<? extends RR,? super E,? super PP1,? super PP2,? super PP3> exceptionHandler)` Convert a 3-argument function which might throw a checked exception into one for which you can decide what happens with the exception.
    `default Function2<R,P2,P3>` | `partial1(P1 argument)` Get a partially applied function.
    `default Function2<R,P1,P3>` | `partial2(P2 argument)` Get a partially applied function.
    `default Function2<R,P1,P2>` | `partial3(P3 argument)` Get a partially applied function.
    `default Function2<R,P2,P3>` | `partialLeft(P1 argument)` Get a partially applied function.
    `default Function2<R,P1,P3>` | `partialMid(P2 argument)` Get a partially applied function.
    `default Function2<R,P1,P2>` | `partialRight(P3 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)

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

    - #### apply

          default R apply(@NotNull
                          ITuple3<? extends P1,? extends P2,? extends P3> tuple3)

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

      Apply this function, but take care to create a fallback. This will return the fallback when `apply(Object, Object, Object)` returns `null`.
      Parameters:
        `arg1` - first argument of this function
        `arg2` - second argument of this function
        `arg3` - third argument of this function
        `fallback` - fallback value returned if function returns `null`
      Returns:
        the non-null result of calling `apply(Object, Object, Object)`, or `fallback` if the result was `null`

    - #### partialLeft

          @NotNull
          default Function2<R,P2,P3> partialLeft(P1 argument)

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

    - #### partial1

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

      Get a partially applied function. This is the same as `partialLeft(Object)`, but with a name which is more consistent with functions having more arguments.
      Parameters:
        `argument` - value applied for first argument
      Returns:
        partially evaluated function

    - #### partialMid

          @NotNull
          default Function2<R,P1,P3> partialMid(P2 argument)

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

    - #### partial2

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

      Get a partially applied function. This is the same as `partialMid(Object)`, but with a name which is more consistent with functions having more arguments.
      Parameters:
        `argument` - value applied for second argument
      Returns:
        partially evaluated function

    - #### partialRight

          @NotNull
          default Function2<R,P1,P2> partialRight(P3 argument)

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

    - #### partial3

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

      Get a partially applied function. This is the same as `partialRight(Object)`, but with a name which is more consistent with functions having more arguments.
      Parameters:
        `argument` - value applied for third argument
      Returns:
        partially evaluated function

    - #### andThen

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

    - #### after1

          @NotNull
          default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,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 `ITuple3` 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 3-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 ITuple3<? extends P1,? extends P2,? extends P3>,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 `ITuple3` 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 3-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 ITuple3<? extends P1,? extends P2,? extends P3>,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 `ITuple3` 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 3-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

    - #### after4

          @NotNull
          default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4> Function4<R,FP1,FP2,FP3,FP4> after4(@NotNull
                                                                                                                                            Function4<FR,FP1,FP2,FP3,FP4> before)

      Get a chained function which first applies the given 4-parameter function, then this one. The given function has to return a `ITuple3` 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 3-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
      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 ITuple3<? extends P1,? extends P2,? extends P3>,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 `ITuple3` 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 3-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 ITuple3<? extends P1,? extends P2,? extends P3>,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 `ITuple3` 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 3-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 ITuple3<? extends P1,? extends P2,? extends P3>,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 `ITuple3` 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 3-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 ITuple3<? extends P1,? extends P2,? extends P3>,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 `ITuple3` 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 3-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 ITuple3<? extends P1,? extends P2,? extends P3>,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 `ITuple3` 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 3-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> Function3<RR,PP1,PP2,PP3> nonFragile(@NotNull
                                                                                                              FragileFunction3<? extends RR,E,? super PP1,? super PP2,? super PP3> fragileFunction)

      Convert a 3-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)`.
      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
      Parameters:
        `fragileFunction` - function throwing a checked exception
      Returns:
        non-fragile function

    - #### nonFragile

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

      Convert a 3-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
      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> Function3<RR,PP1,PP2,PP3> nonFragileX(@NotNull
                                                                                                               FragileFunction3<? extends RR,E,? super PP1,? super PP2,? super PP3> fragileFunction,
                                                                                                               @NotNull
                                                                                                               Function4<? extends RR,? super E,? super PP1,? super PP2,? super PP3> exceptionHandler)

      Convert a 3-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
      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