de.caff.generics.function

## Interface Predicate3<P1,P2,P3>

- Type Parameters:
    `P1` - parameter type 1
    `P2` - parameter type 2
    `P3` - parameter type 3
  All Superinterfaces:
    java.util.function.Predicate<ITuple3<? extends P1,? extends P2,? extends P3>>, Predicate1<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 Predicate3<P1,P2,P3>
      extends Predicate1<ITuple3<? extends P1,? extends P2,? extends P3>>

  A function with three arguments which returns a boolean value.

  Predicates can be chained to simulate boolean logic by `and(Predicate3)`, `or(Predicate3)`, `xor(Predicate3)`, and `negate()`.

  There is a general problem with combining types which don't allow to use the above combination methods in all cases similar to standard Java's logical expressions. The following static methods of this interface may be used in all cases: `and(Predicate3, Predicate3)`, `or(Predicate3, Predicate3)`, and `xor(Predicate3, Predicate3)`.

  Useful for start values in algorithms or as default values are the two values returned by `alwaysTrue()` (a predicate which always returns `true` regardless the argument applied to the `test(Object, Object, Object)` method) and `alwaysFalse()` (same for `false`).

  Partial evaluation is possible via `partialLeft(Object)` which allows to provide a fix first argument, `partialMid(Object)` which provides a fix second argument, and `partialRight(Object)` which provides a fix third argument. All three return a `Predicate2` with the types of the other two arguments.

  The five methods `order132()`, `order213()`, `order231()`, `order312()`, and `order321()` convert a predicate to one which expects a different order of arguments.

  Author:
    Rammi
  See Also:
    `Predicate1`, `Predicate2`, `Predicate4`, `Predicate5`, `Predicate6`, `Predicate7`, `Predicate8`, `Predicate9`

- - ### Field Summary

    - ### Fields inherited from interface de.caff.generics.function.Predicate1

      `ALWAYS_FALSE, ALWAYS_TRUE`

  - ### 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> Predicate1<FP>` | `after1(java.util.function.Function<FP,FR> before)` Get a chained predicate which first applies the given function, then this predicate.
    `default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2> Predicate2<FP1,FP2>` | `after2(java.util.function.BiFunction<FP1,FP2,FR> before)` Get a chained predicate which first applies the given 2-parameter function, then this predicate.
    `default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3> Predicate3<FP1,FP2,FP3>` | `after3(Function3<FR,FP1,FP2,FP3> before)` Get a chained predicate which first applies the given 3-parameter function, then this predicate.
    `default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5> Predicate5<FP1,FP2,FP3,FP4,FP5>` | `after5(Function5<FR,FP1,FP2,FP3,FP4,FP5> before)` Get a chained predicate which first applies the given 5-parameter function, then this predicate.
    `default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6> Predicate6<FP1,FP2,FP3,FP4,FP5,FP6>` | `after6(Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before)` Get a chained predicate which first applies the given 6-parameter function, then this predicate.
    `default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6,FP7> Predicate7<FP1,FP2,FP3,FP4,FP5,FP6,FP7>` | `after7(Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before)` Get a chained predicate 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> Predicate8<FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8>` | `after8(Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before)` Get a chained predicate 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> Predicate9<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 predicate which first applies the given 9-parameter function, then this one.
    `static <T1,T2,T3> Predicate3<T1,T2,T3>` | `alwaysFalse()` Get a predicate which always evaluates to `false`.
    `static <T1,T2,T3> Predicate3<T1,T2,T3>` | `alwaysTrue()` Get a predicate which always evaluates to `true`.
    `default Predicate3<P1,P2,P3>` | `and(Predicate3<? super P1,? super P2,? super P3> other)` Combine this and another predicate with logical and.
    `static <T1,T2,T3> Predicate3<T1,T2,T3>` | `and(Predicate3<? super T1,? super T2,? super T3> pred1, Predicate3<? super T1,? super T2,? super T3> pred2)` Get a predicate which is the combination of two predicates with a logical and.
    `default Predicate3<P1,P2,P3>` | `negate()` Get the negation of this predicate.
    `default Predicate3<P1,P2,P3>` | `or(Predicate3<? super P1,? super P2,? super P3> other)` Combine this and another predicate with logical or.
    `static <T1,T2,T3> Predicate3<T1,T2,T3>` | `or(Predicate3<? super T1,? super T2,? super T3> pred1, Predicate3<? super T1,? super T2,? super T3> pred2)` Get a predicate which is the combination of two predicates with a logical or.
    `default Predicate3<P1,P3,P2>` | `order132()` Get a three argument predicate which expects the arguments in different order.
    `default Predicate3<P2,P1,P3>` | `order213()` Get a three argument predicate which expects the arguments in different order.
    `default Predicate3<P2,P3,P1>` | `order231()` Get a three argument predicate which expects the arguments in different order.
    `default Predicate3<P3,P1,P2>` | `order312()` Get a three argument predicate which expects the arguments in different order.
    `default Predicate3<P3,P2,P1>` | `order321()` Get a three argument predicate which expects the arguments in different order.
    `default Predicate2<P2,P3>` | `partial1(P1 argument)` Get a partially applied predicate with a fix first argument.
    `default Predicate2<P1,P3>` | `partial2(P2 argument)` Get a partially applied predicate with a fix second argument.
    `default Predicate2<P1,P2>` | `partial3(P3 argument)` Get a partially applied predicate with a fix third argument.
    `default Predicate2<P2,P3>` | `partialLeft(P1 argument)` Get a partially applied predicate.
    `default Predicate2<P1,P3>` | `partialMid(P2 argument)` Get a partially applied predicate.
    `default Predicate2<P1,P2>` | `partialRight(P3 argument)` Get a partially applied predicate.
    `default boolean` | `test(ITuple3<? extends P1,? extends P2,? extends P3> tuple3)` Expand a tuple into the arguments of this predicate.
    `boolean` | `test(P1 arg1, P2 arg2, P3 arg3)` Test the given values.
    `default Predicate3<P1,P2,P3>` | `xor(Predicate3<? super P1,? super P2,? super P3> other)` Combine this and another predicate with logical exclusive or.
    `static <T1,T2,T3> Predicate3<T1,T2,T3>` | `xor(Predicate3<? super T1,? super T2,? super T3> pred1, Predicate3<? super T1,? super T2,? super T3> pred2)` Get a predicate which is the combination of two predicates with a logical exclusive or.

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

      `adapted, and_, and, and, from, isEqual, isNull, notNull, or_, or, or, testNonNull, xor_, xor, xor`

- - ### Method Detail

    - #### test

          boolean test(P1 arg1,
                       P2 arg2,
                       P3 arg3)

      Test the given values.
      Parameters:
        `arg1` - function argument 1
        `arg2` - function argument 2
        `arg3` - function argument 3
      Returns:
        `true` or `false`

    - #### test

          default boolean test(@NotNull
                               ITuple3<? extends P1,? extends P2,? extends P3> tuple3)

      Expand a tuple into the arguments of this predicate.
      Specified by:
        `test` in interface `java.util.function.Predicate<ITuple3<? extends P1,? extends P2,? extends P3>>`
      Parameters:
        `tuple3` - tuple to expand
      Returns:
        the result of testing the expended eleeents of the tuple

    - #### and

          @NotNull
          default Predicate3<P1,P2,P3> and(@NotNull
                                                    Predicate3<? super P1,? super P2,? super P3> other)

      Combine this and another predicate with logical and. The result will use shortcut evaluation, so if this predicate already returns `false` the other one is not evaluated.

      This method has a problem if either one of the argument types pf the parameter is not a super class of this predicate's parameter types. See `and(Predicate3, Predicate3)` for such cases.

      Parameters:
        `other` - other predicate to be chained with logical and
      Returns:
        predicates combined with logical and

    - #### or

          @NotNull
          default Predicate3<P1,P2,P3> or(@NotNull
                                                   Predicate3<? super P1,? super P2,? super P3> other)

      Combine this and another predicate with logical or. The result will use shortcut evaluation, so if this predicate already returns `true` the other one is not evaluated.

      This method has a problem if either one of the argument types pf the parameter is not a super class of this predicate's parameter types. See `or(Predicate3, Predicate3)` for such cases.

      Parameters:
        `other` - other predicate to be chained with logical or
      Returns:
        predicates combined with logical or

    - #### xor

          @NotNull
          default Predicate3<P1,P2,P3> xor(@NotNull
                                                    Predicate3<? super P1,? super P2,? super P3> other)

      Combine this and another predicate with logical exclusive or.

      This method has a problem if either one of the argument types pf the parameter is not a super class of this predicate's parameter types. See `xor(Predicate3, Predicate3)` for such cases.

      Parameters:
        `other` - other predicate to be chained with logical exclusive or
      Returns:
        predicates combined with logical exclusive or

    - #### negate

          @NotNull
          default Predicate3<P1,P2,P3> negate()

      Get the negation of this predicate.
      Specified by:
        `negate` in interface `java.util.function.Predicate<ITuple3<? extends P1,? extends P2,? extends P3>>`
      Specified by:
        `negate` in interface `Predicate1<ITuple3<? extends P1,? extends P2,? extends P3>>`
      Returns:
        negation of this predicate

    - #### partialLeft

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

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

    - #### partial1

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

      Get a partially applied predicate with a fix first argument. This is the same as `partialLeft(Object)` but more consitently named.
      Parameters:
        `argument` - value applied for first argument
      Returns:
        partially evaluated two argument predicate

    - #### partialMid

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

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

    - #### partial2

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

      Get a partially applied predicate with a fix second argument. This is the same as `partialMid(Object)` but more consistently named.
      Parameters:
        `argument` - value applied for second argument
      Returns:
        partially evaluated two argument predicate

    - #### partialRight

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

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

    - #### partial3

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

      Get a partially applied predicate with a fix third argument. This is the same as `partialRight(Object)` but more consistently named.
      Parameters:
        `argument` - value applied for third argument
      Returns:
        partially evaluated two argument predicate

    - #### order231

          @NotNull
          default Predicate3<P2,P3,P1> order231()

      Get a three argument predicate which expects the arguments in different order.
      Returns:
        predicate expecting the arguments in order arg2, arg3, arg1

    - #### order312

          @NotNull
          default Predicate3<P3,P1,P2> order312()

      Get a three argument predicate which expects the arguments in different order.
      Returns:
        predicate expecting the arguments in order arg3, arg1, arg2

    - #### order321

          @NotNull
          default Predicate3<P3,P2,P1> order321()

      Get a three argument predicate which expects the arguments in different order.
      Returns:
        predicate expecting the arguments in order arg3, arg2, arg1

    - #### order132

          @NotNull
          default Predicate3<P1,P3,P2> order132()

      Get a three argument predicate which expects the arguments in different order.
      Returns:
        predicate expecting the arguments in order arg1, arg3, arg2

    - #### order213

          @NotNull
          default Predicate3<P2,P1,P3> order213()

      Get a three argument predicate which expects the arguments in different order.
      Returns:
        predicate expecting the arguments in order arg2, arg1, arg3

    - #### alwaysTrue

          @NotNull
          static <T1,T2,T3> Predicate3<T1,T2,T3> alwaysTrue()

      Get a predicate which always evaluates to `true`.
      Specified by:
        `alwaysTrue` in interface `Predicate1<ITuple3<? extends P1,? extends P2,? extends P3>>`
      Type Parameters:
        `T1` - type of first predicate parameter
        `T2` - type of second predicate parameter
        `T3` - type of third predicate parameter
      Returns:
        predicate always returning `true`

    - #### alwaysFalse

          @NotNull
          static <T1,T2,T3> Predicate3<T1,T2,T3> alwaysFalse()

      Get a predicate which always evaluates to `false`.
      Specified by:
        `alwaysFalse` in interface `Predicate1<ITuple3<? extends P1,? extends P2,? extends P3>>`
      Type Parameters:
        `T1` - type of first predicate parameter
        `T2` - type of second predicate parameter
        `T3` - type of third predicate parameter
      Returns:
        predicate always returning `false`

    - #### and

          @NotNull
          static <T1,T2,T3> Predicate3<T1,T2,T3> and(@NotNull
                                                              Predicate3<? super T1,? super T2,? super T3> pred1,
                                                              @NotNull
                                                              Predicate3<? super T1,? super T2,? super T3> pred2)

      Get a predicate which is the combination of two predicates with a logical and.

      The result will use shortcut evaluation, so if this predicate already returns `false` the other one is not evaluated.

      Type Parameters:
        `T1` - resulting type of first argument, which is the most extending type of both `pred1`'s first argument type and `pred2`'s first argument type, so if neither type is extending the other this method will not compile
        `T2` - resulting type of second argument, see `<T1>` for the fine print
        `T3` - resulting type of third argument, see `<T1>` for the fine print
      Parameters:
        `pred1` - first predicate
        `pred2` - second predicate
      Returns:
        combination of both predicates with logical and
      See Also:
        `and(Predicate3)`

    - #### or

          @NotNull
          static <T1,T2,T3> Predicate3<T1,T2,T3> or(@NotNull
                                                             Predicate3<? super T1,? super T2,? super T3> pred1,
                                                             @NotNull
                                                             Predicate3<? super T1,? super T2,? super T3> pred2)

      Get a predicate which is the combination of two predicates with a logical or.

      The result will use shortcut evaluation, so if this predicate already returns `true` the other one is not evaluated.

      Type Parameters:
        `T1` - resulting type of first argument, which is the most extending type of both `pred1`'s first argument type and `pred2`'s first argument type, so if neither type is extending the other this method will not compile
        `T2` - resulting type of second argument, see `<T1>` for the fine print
        `T3` - resulting type of third argument, see `<T1>` for the fine print
      Parameters:
        `pred1` - first predicate
        `pred2` - second predicate
      Returns:
        combination of both predicates with logical or
      See Also:
        `or(Predicate3)`

    - #### xor

          @NotNull
          static <T1,T2,T3> Predicate3<T1,T2,T3> xor(@NotNull
                                                              Predicate3<? super T1,? super T2,? super T3> pred1,
                                                              @NotNull
                                                              Predicate3<? super T1,? super T2,? super T3> pred2)

      Get a predicate which is the combination of two predicates with a logical exclusive or.

      The result will use shortcut evaluation, so if this predicate already returns `true` the other one is not evaluated.

      Type Parameters:
        `T1` - resulting type of first argument, which is the most extending type of both `pred1`'s first argument type and `pred2`'s first argument type, so if neither type is extending the other this method will not compile
        `T2` - resulting type of second argument, see `<T1>` for the fine print
        `T3` - resulting type of third argument, see `<T1>` for the fine print
      Parameters:
        `pred1` - first predicate
        `pred2` - second predicate
      Returns:
        combination of both predicates with logical exclusive or
      See Also:
        `xor(Predicate3)`

    - #### after1

          @NotNull
          default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP> Predicate1<FP> after1(@NotNull
                                                                                                                 java.util.function.Function<FP,FR> before)

      Get a chained predicate which first applies the given function, then this predicate. The given function has to return a `ITuple3` with matching parametric types which are applied in their order to this predicate.
      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 predicate
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        chain of function and this predicate

    - #### after2

          @NotNull
          default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2> Predicate2<FP1,FP2> after2(@NotNull
                                                                                                                           java.util.function.BiFunction<FP1,FP2,FR> before)

      Get a chained predicate which first applies the given 2-parameter function, then this predicate. The given function has to return a `ITuple3` with matching parametric types which are applied in their order to this predicate.
      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 predicate
        `FP2` - function `before`'s second parameter type, same for returned predicate
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        chain of the given function and this predicate

    - #### after3

          @NotNull
          default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3> Predicate3<FP1,FP2,FP3> after3(@NotNull
                                                                                                                                   Function3<FR,FP1,FP2,FP3> before)

      Get a chained predicate which first applies the given 3-parameter function, then this predicate. The given function has to return a `ITuple3` with matching parametric types which are applied in their order to this predicate.
      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 predicate
        `FP2` - function `before`'s second parameter type, sane for returned predicate
        `FP3` - function `before`'s third parameter type, sane for returned predicate
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        chain of the given function and this predicate

    - #### after5

          @NotNull
          default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5> Predicate5<FP1,FP2,FP3,FP4,FP5> after5(@NotNull
                                                                                                                                                   Function5<FR,FP1,FP2,FP3,FP4,FP5> before)

      Get a chained predicate which first applies the given 5-parameter function, then this predicate. 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 predicate
        `FP2` - function `before`'s second parameter type, sane for returned predicate
        `FP3` - function `before`'s third parameter type, sane for returned predicate
        `FP4` - function `before`'s fourth parameter type, sane for returned predicate
        `FP5` - function `before`'s fifth parameter type, sane for returned predicate
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        chain of the given function and this predicate

    - #### after6

          @NotNull
          default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6> Predicate6<FP1,FP2,FP3,FP4,FP5,FP6> after6(@NotNull
                                                                                                                                                           Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before)

      Get a chained predicate which first applies the given 6-parameter function, then this predicate. 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 predicate
        `FP2` - function `before`'s second parameter type, sane for returned predicate
        `FP3` - function `before`'s third parameter type, sane for returned predicate
        `FP4` - function `before`'s fourth parameter type, sane for returned predicate
        `FP5` - function `before`'s fifth parameter type, sane for returned predicate
        `FP6` - function `before`'s sixth parameter type, sane for returned predicate
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        chain of the given function and this predicate

    - #### after7

          @NotNull
          default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6,FP7> Predicate7<FP1,FP2,FP3,FP4,FP5,FP6,FP7> after7(@NotNull
                                                                                                                                                                   Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before)

      Get a chained predicate 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 predicate.
      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 predicate
        `FP2` - function `before`'s second parameter type, sane for returned predicate
        `FP3` - function `before`'s third parameter type, sane for returned predicate
        `FP4` - function `before`'s fourth parameter type, sane for returned predicate
        `FP5` - function `before`'s fifth parameter type, sane for returned predicate
        `FP6` - function `before`'s sixth parameter type, sane for returned predicate
        `FP7` - function `before`'s seventh parameter type, sane for returned predicate
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        chain of the given function and this predicate

    - #### after8

          @NotNull
          default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> Predicate8<FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> after8(@NotNull
                                                                                                                                                                           Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before)

      Get a chained predicate 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 predicate.
      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 predicate
        `FP2` - function `before`'s second parameter type, sane for returned predicate
        `FP3` - function `before`'s third parameter type, sane for returned predicate
        `FP4` - function `before`'s fourth parameter type, sane for returned predicate
        `FP5` - function `before`'s fifth parameter type, sane for returned predicate
        `FP6` - function `before`'s sixth parameter type, sane for returned predicate
        `FP7` - function `before`'s seventh parameter type, sane for returned predicate
        `FP8` - function `before`'s seventh parameter type, sane for returned predicate
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        chain of the given function and this predicate

    - #### after9

          @NotNull
          default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> Predicate9<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 predicate 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 predicate.
      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 predicate
        `FP2` - function `before`'s second parameter type, sane for returned predicate
        `FP3` - function `before`'s third parameter type, sane for returned predicate
        `FP4` - function `before`'s fourth parameter type, sane for returned predicate
        `FP5` - function `before`'s fifth parameter type, sane for returned predicate
        `FP6` - function `before`'s sixth parameter type, sane for returned predicate
        `FP7` - function `before`'s seventh parameter type, sane for returned predicate
        `FP8` - function `before`'s seventh parameter type, sane for returned predicate
        `FP9` - function `before`'s ninth parameter type, sane for returned predicate
      Parameters:
        `before` - function to apply first, has to return a non-`null` result so unpacking the parameters from the tuple is possible
      Returns:
        chain of the given function and this predicate