de.caff.generics.function

## Interface Predicate7<P1,P2,P3,P4,P5,P6,P7>

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

  A function with seven arguments which returns a boolean value.

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

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

  Partial evaluation is also possible.

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

      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
        `arg6` - function argument 6
        `arg7` - function argument 7
      Returns:
        `true` or `false`

    - #### test

          default boolean test(@NotNull
                               ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7> tuple7)

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

    - #### and

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

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

    - #### or

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

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

    - #### xor

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

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

    - #### negate

          @NotNull
          default Predicate7<P1,P2,P3,P4,P5,P6,P7> negate()

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

    - #### partial1

          @NotNull
          default Predicate6<P2,P3,P4,P5,P6,P7> 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 Predicate6<P1,P3,P4,P5,P6,P7> 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 Predicate6<P1,P2,P4,P5,P6,P7> 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 Predicate6<P1,P2,P3,P5,P6,P7> 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 Predicate6<P1,P2,P3,P4,P6,P7> 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

    - #### partial6

          @NotNull
          default Predicate6<P1,P2,P3,P4,P5,P7> partial6(P6 argument)

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

    - #### partial7

          @NotNull
          default Predicate6<P1,P2,P3,P4,P5,P6> partial7(P7 argument)

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

    - #### alwaysTrue

          @NotNull
          static <T1,T2,T3,T4,T5,T6,T7> Predicate7<T1,T2,T3,T4,T5,T6,T7> alwaysTrue()

      Get a predicate which always evaluates to `true`.
      Specified by:
        `alwaysTrue` in interface `Predicate1<ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>>`
      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
        `T6` - type of sixth predicate parameter
        `T7` - type of seventh predicate parameter
      Returns:
        predicate always returning `true`

    - #### alwaysFalse

          @NotNull
          static <T1,T2,T3,T4,T5,T6,T7> Predicate7<T1,T2,T3,T4,T5,T6,T7> alwaysFalse()

      Get a predicate which always evaluates to `false`.
      Specified by:
        `alwaysFalse` in interface `Predicate1<ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>>`
      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
        `T6` - type of sixth predicate parameter
        `T7` - type of seventh predicate parameter
      Returns:
        predicate always returning `false`

    - #### and

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

    - #### or

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

    - #### xor

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

    - #### after1

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