de.caff.generics.function

## Interface Predicate5<P1,P2,P3,P4,P5>

- Type Parameters:
    `P1` - parameter type 1
    `P2` - parameter type 2
    `P3` - parameter type 3
    `P4` - parameter type 4
    `P5` - parameter type 5
  All Superinterfaces:
    java.util.function.Predicate<ITuple5<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5>>, Predicate1<ITuple5<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5>>
  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 Predicate5<P1,P2,P3,P4,P5>
      extends Predicate1<ITuple5<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5>>

  A function with five arguments which returns a boolean value.

  Predicates can be chained to simulate boolean logic by `and(Predicate5)`, `or(Predicate5)`, `xor(Predicate5)`, 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(Predicate5, Predicate5)`, `or(Predicate5, Predicate5)`, and `xor(Predicate5, Predicate5)`.

  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, Object, Object)` method) and `alwaysFalse()` (same for `false`).

  Partial evaluation is also possible.

  Author:
    Rammi
  See Also:
    `Predicate1`, `Predicate2`, `Predicate3`, `Predicate4`, `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 ITuple5<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5>,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 ITuple5<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5>,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 ITuple5<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5>,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 ITuple5<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5>,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 ITuple5<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5>,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 ITuple5<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5>,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 ITuple5<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5>,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 ITuple5<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5>,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,T4,T5> Predicate5<T1,T2,T3,T4,T5>` | `alwaysFalse()` Get a predicate which always evaluates to `false`.
    `static <T1,T2,T3,T4,T5> Predicate5<T1,T2,T3,T4,T5>` | `alwaysTrue()` Get a predicate which always evaluates to `true`.
    `default Predicate5<P1,P2,P3,P4,P5>` | `and(Predicate5<? super P1,? super P2,? super P3,? super P4,? super P5> other)` Combine this and another predicate with logical and.
    `static <T1,T2,T3,T4,T5> Predicate5<T1,T2,T3,T4,T5>` | `and(Predicate5<? super T1,? super T2,? super T3,? super T4,? super T5> pred1, Predicate5<? super T1,? super T2,? super T3,? super T4,? super T5> pred2)` Get a predicate which is the combination of two predicates with a logical and.
    `default Predicate5<P1,P2,P3,P4,P5>` | `negate()` Get the negation of this predicate.
    `default Predicate5<P1,P2,P3,P4,P5>` | `or(Predicate5<? super P1,? super P2,? super P3,? super P4,? super P5> other)` Combine this and another predicate with logical or.
    `static <T1,T2,T3,T4,T5> Predicate5<T1,T2,T3,T4,T5>` | `or(Predicate5<? super T1,? super T2,? super T3,? super T4,? super T5> pred1, Predicate5<? super T1,? super T2,? super T3,? super T4,? super T5> pred2)` Get a predicate which is the combination of two predicates with a logical or.
    `default Predicate4<P2,P3,P4,P5>` | `partial1(P1 argument)` Get a partially applied predicate with a fix first argument.
    `default Predicate4<P1,P3,P4,P5>` | `partial2(P2 argument)` Get a partially applied predicate with a fix second argument.
    `default Predicate4<P1,P2,P4,P5>` | `partial3(P3 argument)` Get a partially applied predicate with a fix third argument.
    `default Predicate4<P1,P2,P3,P5>` | `partial4(P4 argument)` Get a partially applied predicate with a fix fourth argument.
    `default Predicate4<P1,P2,P3,P4>` | `partial5(P5 argument)` Get a partially applied predicate with a fix fifth argument.
    `default boolean` | `test(ITuple5<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5> tuple5)` Expand a tuple into the arguments of this predicate.
    `boolean` | `test(P1 arg1, P2 arg2, P3 arg3, P4 arg4, P5 arg5)` Test the given values.
    `default Predicate5<P1,P2,P3,P4,P5>` | `xor(Predicate5<? super P1,? super P2,? super P3,? super P4,? super P5> other)` Combine this and another predicate with logical exclusive or.
    `static <T1,T2,T3,T4,T5> Predicate5<T1,T2,T3,T4,T5>` | `xor(Predicate5<? super T1,? super T2,? super T3,? super T4,? super T5> pred1, Predicate5<? super T1,? super T2,? super T3,? super T4,? super T5> 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,
                       P4 arg4,
                       P5 arg5)

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

    - #### test

          default boolean test(@NotNull
                               ITuple5<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5> tuple5)

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

    - #### and

          @NotNull
          default Predicate5<P1,P2,P3,P4,P5> and(@NotNull
                                                          Predicate5<? super P1,? super P2,? super P3,? super P4,? super P5> 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(Predicate5, Predicate5)` for such cases.

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

    - #### or

          @NotNull
          default Predicate5<P1,P2,P3,P4,P5> or(@NotNull
                                                         Predicate5<? super P1,? super P2,? super P3,? super P4,? super P5> 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(Predicate5, Predicate5)` for such cases.

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

    - #### xor

          @NotNull
          default Predicate5<P1,P2,P3,P4,P5> xor(@NotNull
                                                          Predicate5<? super P1,? super P2,? super P3,? super P4,? super P5> 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(Predicate5, Predicate5)` for such cases.

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

    - #### negate

          @NotNull
          default Predicate5<P1,P2,P3,P4,P5> negate()

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

    - #### partial1

          @NotNull
          default Predicate4<P2,P3,P4,P5> partial1(P1 argument)

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

    - #### partial2

          @NotNull
          default Predicate4<P1,P3,P4,P5> partial2(P2 argument)

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

    - #### partial3

          @NotNull
          default Predicate4<P1,P2,P4,P5> partial3(P3 argument)

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

    - #### partial4

          @NotNull
          default Predicate4<P1,P2,P3,P5> partial4(P4 argument)

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

    - #### partial5

          @NotNull
          default Predicate4<P1,P2,P3,P4> partial5(P5 argument)

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

    - #### alwaysTrue

          @NotNull
          static <T1,T2,T3,T4,T5> Predicate5<T1,T2,T3,T4,T5> alwaysTrue()

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

    - #### alwaysFalse

          @NotNull
          static <T1,T2,T3,T4,T5> Predicate5<T1,T2,T3,T4,T5> alwaysFalse()

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

    - #### and

          @NotNull
          static <T1,T2,T3,T4,T5> Predicate5<T1,T2,T3,T4,T5> and(@NotNull
                                                                          Predicate5<? super T1,? super T2,? super T3,? super T4,? super T5> pred1,
                                                                          @NotNull
                                                                          Predicate5<? super T1,? super T2,? super T3,? super T4,? super T5> 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
        `T4` - resulting type of fourth argument, see `<T1>` for the fine print
        `T5` - resulting type of fifth 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(Predicate5)`

    - #### or

          @NotNull
          static <T1,T2,T3,T4,T5> Predicate5<T1,T2,T3,T4,T5> or(@NotNull
                                                                         Predicate5<? super T1,? super T2,? super T3,? super T4,? super T5> pred1,
                                                                         @NotNull
                                                                         Predicate5<? super T1,? super T2,? super T3,? super T4,? super T5> 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
        `T4` - resulting type of fourth argument, see `<T1>` for the fine print
        `T5` - resulting type of fifth 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(Predicate5)`

    - #### xor

          @NotNull
          static <T1,T2,T3,T4,T5> Predicate5<T1,T2,T3,T4,T5> xor(@NotNull
                                                                          Predicate5<? super T1,? super T2,? super T3,? super T4,? super T5> pred1,
                                                                          @NotNull
                                                                          Predicate5<? super T1,? super T2,? super T3,? super T4,? super T5> 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
        `T4` - resulting type of fourth argument, see `<T1>` for the fine print
        `T5` - resulting type of fifth 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(Predicate5)`

    - #### after1

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