de.caff.generics.tuple

## Interface ITuple2<T1,T2>

- Type Parameters:
    `T1` - type of first element
    `T2` - type of second element
  All Known Subinterfaces:
    NamedNullableValue<T>, NamedValue<T>
  All Known Implementing Classes:
    Dict.Entry, ITuple2.Base, NTuple2, OrderedPair, Pair, Tuple2

      public interface ITuple2<T1,T2>

  General interface for immutable 2-tuples.

  This is sometimes useful to access either `Tuple2` or `NTuple2` in a general way, although in most cases the concrete implementations are usually preferable.

  If you want to iterate over a tuple or access its elements by index (note that both is only possible for a common super type of the tuple's types) `Indexable.viewTuple(ITuple2)` will come to help.

  Note that this class is automatically created by `tools.TupleClassCreator` (not yet public).

  Since:
    November 17, 2021
  Author:
    Rammi
  See Also:
    `Tuple2`, `NTuple2`

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Interface and Description
    --- | ---
    `static class` | `ITuple2.Base<T1,T2>` Abstract base implementation of a 2-tuple.

  - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `T1` | `_1()` Get the first element.
    `T2` | `_2()` Get the second element.
    `default ITuple2<T2,T1>` | `_21()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 1st.
    `default ITuple2.Base<T1,T2>` | `asBase()` Convert this 2-tuple into a `base tuple` which provides useful implementations for standard methods.
    `static <S1,E1,E2,R> java.util.function.Function<S1,R>` | `concat1(java.util.function.Function<S1,? extends ITuple2<? extends E1,? extends E2>> fn1, java.util.function.BiFunction<? super E1,? super E2,R> fn2)` Combine a 1-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 1-argument function.
    `static <S1,S2,E1,E2,R> java.util.function.BiFunction<S1,S2,R>` | `concat2(java.util.function.BiFunction<S1,S2,? extends ITuple2<? extends E1,? extends E2>> fn1, java.util.function.BiFunction<? super E1,? super E2,R> fn2)` Combine a 2-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 2-argument function.
    `static <S1,S2,S3,E1,E2,R> Function3<R,S1,S2,S3>` | `concat3(Function3<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3> fn1, java.util.function.BiFunction<? super E1,? super E2,R> fn2)` Combine a 3-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 3-argument function.
    `static <S1,S2,S3,S4,E1,E2,R> Function4<R,S1,S2,S3,S4>` | `concat4(Function4<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4> fn1, java.util.function.BiFunction<? super E1,? super E2,R> fn2)` Combine a 4-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 4-argument function.
    `static <S1,S2,S3,S4,S5,E1,E2,R> Function5<R,S1,S2,S3,S4,S5>` | `concat5(Function5<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5> fn1, java.util.function.BiFunction<? super E1,? super E2,R> fn2)` Combine a 5-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 5-argument function.
    `static <S1,S2,S3,S4,S5,S6,E1,E2,R> Function6<R,S1,S2,S3,S4,S5,S6>` | `concat6(Function6<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6> fn1, java.util.function.BiFunction<? super E1,? super E2,R> fn2)` Combine a 6-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 6-argument function.
    `static <S1,S2,S3,S4,S5,S6,S7,E1,E2,R> Function7<R,S1,S2,S3,S4,S5,S6,S7>` | `concat7(Function7<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6,S7> fn1, java.util.function.BiFunction<? super E1,? super E2,R> fn2)` Combine a 7-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 7-argument function.
    `static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,R> Function8<R,S1,S2,S3,S4,S5,S6,S7,S8>` | `concat8(Function8<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, java.util.function.BiFunction<? super E1,? super E2,R> fn2)` Combine a 8-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 8-argument function.
    `static <S1,E1,E2> java.util.function.Predicate<S1>` | `concatPred1(java.util.function.Function<S1,? extends ITuple2<? extends E1,? extends E2>> fn1, java.util.function.BiPredicate<? super E1,? super E2> pred2)` Combine a 1-argument function returning a 2-tuple with a 2-parameter predicate into a 1-argument predicate.
    `static <S1,S2,E1,E2> java.util.function.BiPredicate<S1,S2>` | `concatPred2(java.util.function.BiFunction<S1,S2,? extends ITuple2<? extends E1,? extends E2>> fn1, java.util.function.BiPredicate<? super E1,? super E2> pred2)` Combine a 2-argument function returning a 2-tuple with a 2-parameter predicate into a 2-argument predicate.
    `static <S1,S2,S3,E1,E2> Predicate3<S1,S2,S3>` | `concatPred3(Function3<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3> fn1, java.util.function.BiPredicate<? super E1,? super E2> pred2)` Combine a 3-argument function returning a 2-tuple with a 2-parameter predicate into a 3-argument predicate.
    `static <S1,S2,S3,S4,E1,E2> Predicate4<S1,S2,S3,S4>` | `concatPred4(Function4<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4> fn1, java.util.function.BiPredicate<? super E1,? super E2> pred2)` Combine a 4-argument function returning a 2-tuple with a 2-parameter predicate into a 4-argument predicate.
    `static <S1,S2,S3,S4,S5,E1,E2> Predicate5<S1,S2,S3,S4,S5>` | `concatPred5(Function5<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5> fn1, java.util.function.BiPredicate<? super E1,? super E2> pred2)` Combine a 5-argument function returning a 2-tuple with a 2-parameter predicate into a 5-argument predicate.
    `static <S1,S2,S3,S4,S5,S6,E1,E2> Predicate6<S1,S2,S3,S4,S5,S6>` | `concatPred6(Function6<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6> fn1, java.util.function.BiPredicate<? super E1,? super E2> pred2)` Combine a 6-argument function returning a 2-tuple with a 2-parameter predicate into a 6-argument predicate.
    `static <S1,S2,S3,S4,S5,S6,S7,E1,E2> Predicate7<S1,S2,S3,S4,S5,S6,S7>` | `concatPred7(Function7<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6,S7> fn1, java.util.function.BiPredicate<? super E1,? super E2> pred2)` Combine a 7-argument function returning a 2-tuple with a 2-parameter predicate into a 7-argument predicate.
    `static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2> Predicate8<S1,S2,S3,S4,S5,S6,S7,S8>` | `concatPred8(Function8<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, java.util.function.BiPredicate<? super E1,? super E2> pred2)` Combine a 8-argument function returning a 2-tuple with a 2-parameter predicate into a 8-argument predicate.
    `static <S1,E1,E2> java.util.function.Consumer<S1>` | `concatProc1(java.util.function.Function<S1,? extends ITuple2<? extends E1,? extends E2>> fn1, java.util.function.BiConsumer<? super E1,? super E2> proc2)` Combine a 1-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 1-argument consumer/procedure.
    `static <S1,S2,E1,E2> java.util.function.BiConsumer<S1,S2>` | `concatProc2(java.util.function.BiFunction<S1,S2,? extends ITuple2<? extends E1,? extends E2>> fn1, java.util.function.BiConsumer<? super E1,? super E2> proc2)` Combine a 2-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 2-argument consumer/procedure.
    `static <S1,S2,S3,E1,E2> Procedure3<S1,S2,S3>` | `concatProc3(Function3<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3> fn1, java.util.function.BiConsumer<? super E1,? super E2> proc2)` Combine a 3-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 3-argument consumer/procedure.
    `static <S1,S2,S3,S4,E1,E2> Procedure4<S1,S2,S3,S4>` | `concatProc4(Function4<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4> fn1, java.util.function.BiConsumer<? super E1,? super E2> proc2)` Combine a 4-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 4-argument consumer/procedure.
    `static <S1,S2,S3,S4,S5,E1,E2> Procedure5<S1,S2,S3,S4,S5>` | `concatProc5(Function5<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5> fn1, java.util.function.BiConsumer<? super E1,? super E2> proc2)` Combine a 5-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 5-argument consumer/procedure.
    `static <S1,S2,S3,S4,S5,S6,E1,E2> Procedure6<S1,S2,S3,S4,S5,S6>` | `concatProc6(Function6<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6> fn1, java.util.function.BiConsumer<? super E1,? super E2> proc2)` Combine a 6-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 6-argument consumer/procedure.
    `static <S1,S2,S3,S4,S5,S6,S7,E1,E2> Procedure7<S1,S2,S3,S4,S5,S6,S7>` | `concatProc7(Function7<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6,S7> fn1, java.util.function.BiConsumer<? super E1,? super E2> proc2)` Combine a 7-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 7-argument consumer/procedure.
    `static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2> Procedure8<S1,S2,S3,S4,S5,S6,S7,S8>` | `concatProc8(Function8<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, java.util.function.BiConsumer<? super E1,? super E2> proc2)` Combine a 8-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 8-argument consumer/procedure.
    `static boolean` | `equals(ITuple2<?,?> tuple, java.lang.Object o)` Basic implementation of equals for 2-tuples.
    `default NTuple2<T1,T2>` | `frozen()` Convert this into an object of a concrete tuple implementation.
    `default Tuple2<T1,T2>` | `frozenNotNull()` Convert this into an object of a concrete tuple implementation.
    `static int` | `hash(ITuple2<?,?> tuple)` Basic implementation for calculating a hash code of a 2-tuple.
    `default <T> T` | `invoke(java.util.function.BiFunction<? super T1,? super T2,T> function)` Invoke a 2-argument function on this tuple unpacked.
    `default void` | `sendTo(java.util.function.BiConsumer<? super T1,? super T2> procedure)` Send this tuple unpacked to a 2-argument procedure.
    `default boolean` | `testBy(java.util.function.BiPredicate<? super T1,? super T2> predicate)` Test a 2-argument predicate with this tuple unpacked.
    `static java.lang.String` | `toString(ITuple2<?,?> tuple)` Basic implementation for creating a string from a 2-tuple.
    `static java.lang.String` | `toString(java.lang.String prefix, ITuple2<?,?> tuple)` Basic implementation for creating a string from a 2-tuple.
    `static <E1,E2> ITuple2<E1,E2>` | `view(E1 elem1, E2 elem2)` Create a new 2-tuple on the fly.

- - ### Method Detail

    - #### _1

          T1 _1()

      Get the first element.
      Returns:
        first element

    - #### _2

          T2 _2()

      Get the second element.
      Returns:
        second element

    - #### _21

          @NotNull
          default ITuple2<T2,T1> _21()

      Create a new 2-tuple from this one where the elements are ordered: 2nd, 1st.
      Returns:
        reordered tuple

    - #### asBase

          @NotNull
          default ITuple2.Base<T1,T2> asBase()

      Convert this 2-tuple into a `base tuple` which provides useful implementations for standard methods.
      Returns:
        base view of this tuple

    - #### frozen

          @NotNull
          default NTuple2<T1,T2> frozen()

      Convert this into an object of a concrete tuple implementation. This is useful because implementations may just be a view of something else. This method makes sure to decouple the tuple from the viewed object. The resulting tuple may contain `null` elements, see `frozenNotNull()` for a method which returns tuples which don't have nullable elements.
      Returns:
        standalone tuple object

    - #### frozenNotNull

          @NotNull
          default Tuple2<T1,T2> frozenNotNull()

      Convert this into an object of a concrete tuple implementation. This is useful because implementations may just be a view of something else. This method makes sure to decouple the tuple from the viewed object. The resulting tuple is guaranteed not to have `null` elements, but if this interface has `null` elements this method will throw a `NullPointerException`.

      See `frozen()` for a method which will not throw exceptions.

      Returns:
        standalone tuple object
      Throws:
        `java.lang.NullPointerException` - if any element of this tuple is `null`

    - #### invoke

          default <T> T invoke(@NotNull
                               java.util.function.BiFunction<? super T1,? super T2,T> function)

      Invoke a 2-argument function on this tuple unpacked.
      Type Parameters:
        `T` - function return type
      Parameters:
        `function` - function called with the unpacked elements of this tuple
      Returns:
        result of calling the function

    - #### sendTo

          default void sendTo(@NotNull
                              java.util.function.BiConsumer<? super T1,? super T2> procedure)

      Send this tuple unpacked to a 2-argument procedure.
      Parameters:
        `procedure` - procedure called with the unpacked elements of this tuple

    - #### testBy

          default boolean testBy(@NotNull
                                 java.util.function.BiPredicate<? super T1,? super T2> predicate)

      Test a 2-argument predicate with this tuple unpacked.
      Parameters:
        `predicate` - predicate called with the unpacked elements of this tuple
      Returns:
        predicate's result

    - #### view

          @NotNull
          static <E1,E2> ITuple2<E1,E2> view(E1 elem1,
                                                      E2 elem2)

      Create a new 2-tuple on the fly. This is especially useful for temporary usage, you might want to create a `Tuple2` instead as that gives guarantees of the non-nullness of its elements, or a `NTuple2` as that at least is serializable (as is `Tuple2`).
      Type Parameters:
        `E1` - type of first element
        `E2` - type of second element
      Parameters:
        `elem1` - first element of returned tuple
        `elem2` - second element of returned tuple
      Returns:
        2-tuple view of the given elements

    - #### equals

          static boolean equals(@NotNull
                                ITuple2<?,?> tuple,
                                @Nullable
                                java.lang.Object o)

      Basic implementation of equals for 2-tuples. This can be used in implementations to implement `Object.equals(Object)`. Don't forget hashing: `hash(ITuple2)`
      Parameters:
        `tuple` - tuple to compare
        `o` - other object to compare
      Returns:
        `false` if `o` is `null`, not a `ITuple2`, or its members differ
        `true` otherwise

    - #### hash

          static int hash(@NotNull
                          ITuple2<?,?> tuple)

      Basic implementation for calculating a hash code of a 2-tuple. This can be used in implementations to implement `Object.hashCode()`. Don't forget equals: `equals(ITuple2, Object)`.
      Parameters:
        `tuple` - tuple to hash
      Returns:
        hash code

    - #### toString

          @NotNull
          static java.lang.String toString(@NotNull
                                                    ITuple2<?,?> tuple)

      Basic implementation for creating a string from a 2-tuple. This one uses `"ITuple2"` as prefix. This can be used im implementations to implement `Object.toString()`.
      Parameters:
        `tuple` - tuple to convert
      Returns:
        text form
      See Also:
        `toString(String, ITuple2)`

    - #### toString

          @NotNull
          static java.lang.String toString(@NotNull
                                                    java.lang.String prefix,
                                                    @NotNull
                                                    ITuple2<?,?> tuple)

      Basic implementation for creating a string from a 2-tuple. This can be used im implementations to implement `Object.toString()`.
      Parameters:
        `prefix` - prefix for the output
        `tuple` - tuple to convert
      Returns:
        text form
      See Also:
        `toString(ITuple2)`

    - #### concat1

          @NotNull
          static <S1,E1,E2,R> java.util.function.Function<S1,R> concat1(@NotNull
                                                                                 java.util.function.Function<S1,? extends ITuple2<? extends E1,? extends E2>> fn1,
                                                                                 @NotNull
                                                                                 java.util.function.BiFunction<? super E1,? super E2,R> fn2)

      Combine a 1-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 1-argument function.
      Type Parameters:
        `S1` - first argument of incoming function `fn1` and returned function
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
        `R` - result type
      Parameters:
        `fn1` - 1-argument function returning a 2-tuple
        `fn2` - 2-argument function which can use the expanded tuple elements as arguments and returns the result value
      Returns:
        1-argument function which returns the result value

    - #### concatProc1

          @NotNull
          static <S1,E1,E2> java.util.function.Consumer<S1> concatProc1(@NotNull
                                                                                 java.util.function.Function<S1,? extends ITuple2<? extends E1,? extends E2>> fn1,
                                                                                 @NotNull
                                                                                 java.util.function.BiConsumer<? super E1,? super E2> proc2)

      Combine a 1-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 1-argument consumer/procedure.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 1-argument function returning a 2-tuple
        `proc2` - 2-argument consumer/procedure which can use the expanded tuple elements as arguments
      Returns:
        1-argument consumer/procedure which returns the result value

    - #### concatPred1

          @NotNull
          static <S1,E1,E2> java.util.function.Predicate<S1> concatPred1(@NotNull
                                                                                  java.util.function.Function<S1,? extends ITuple2<? extends E1,? extends E2>> fn1,
                                                                                  @NotNull
                                                                                  java.util.function.BiPredicate<? super E1,? super E2> pred2)

      Combine a 1-argument function returning a 2-tuple with a 2-parameter predicate into a 1-argument predicate.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 1-argument function returning a 2-tuple
        `pred2` - 2-argument predicate which can use the expanded tuple elements as arguments
      Returns:
        1-argument predicate which returns the test result of the tuple returned by `fn1`

    - #### concat2

          @NotNull
          static <S1,S2,E1,E2,R> java.util.function.BiFunction<S1,S2,R> concat2(@NotNull
                                                                                         java.util.function.BiFunction<S1,S2,? extends ITuple2<? extends E1,? extends E2>> fn1,
                                                                                         @NotNull
                                                                                         java.util.function.BiFunction<? super E1,? super E2,R> fn2)

      Combine a 2-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 2-argument function.
      Type Parameters:
        `S1` - first argument of incoming function `fn1` and returned function
        `S2` - second argument of incoming function `fn1` and returned function
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
        `R` - result type
      Parameters:
        `fn1` - 2-argument function returning a 2-tuple
        `fn2` - 2-argument function which can use the expanded tuple elements as arguments and returns the result value
      Returns:
        2-argument function which returns the result value

    - #### concatProc2

          @NotNull
          static <S1,S2,E1,E2> java.util.function.BiConsumer<S1,S2> concatProc2(@NotNull
                                                                                         java.util.function.BiFunction<S1,S2,? extends ITuple2<? extends E1,? extends E2>> fn1,
                                                                                         @NotNull
                                                                                         java.util.function.BiConsumer<? super E1,? super E2> proc2)

      Combine a 2-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 2-argument consumer/procedure.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 2-argument function returning a 2-tuple
        `proc2` - 2-argument consumer/procedure which can use the expanded tuple elements as arguments
      Returns:
        2-argument consumer/procedure which returns the result value

    - #### concatPred2

          @NotNull
          static <S1,S2,E1,E2> java.util.function.BiPredicate<S1,S2> concatPred2(@NotNull
                                                                                          java.util.function.BiFunction<S1,S2,? extends ITuple2<? extends E1,? extends E2>> fn1,
                                                                                          @NotNull
                                                                                          java.util.function.BiPredicate<? super E1,? super E2> pred2)

      Combine a 2-argument function returning a 2-tuple with a 2-parameter predicate into a 2-argument predicate.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 2-argument function returning a 2-tuple
        `pred2` - 2-argument predicate which can use the expanded tuple elements as arguments
      Returns:
        2-argument predicate which returns the test result of the tuple returned by `fn1`

    - #### concat3

          @NotNull
          static <S1,S2,S3,E1,E2,R> Function3<R,S1,S2,S3> concat3(@NotNull
                                                                           Function3<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3> fn1,
                                                                           @NotNull
                                                                           java.util.function.BiFunction<? super E1,? super E2,R> fn2)

      Combine a 3-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 3-argument function.
      Type Parameters:
        `S1` - first argument of incoming function `fn1` and returned function
        `S2` - second argument of incoming function `fn1` and returned function
        `S3` - third argument of incoming function `fn1` and returned function
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
        `R` - result type
      Parameters:
        `fn1` - 3-argument function returning a 2-tuple
        `fn2` - 2-argument function which can use the expanded tuple elements as arguments and returns the result value
      Returns:
        3-argument function which returns the result value

    - #### concatProc3

          @NotNull
          static <S1,S2,S3,E1,E2> Procedure3<S1,S2,S3> concatProc3(@NotNull
                                                                            Function3<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3> fn1,
                                                                            @NotNull
                                                                            java.util.function.BiConsumer<? super E1,? super E2> proc2)

      Combine a 3-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 3-argument consumer/procedure.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `S3` - third argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 3-argument function returning a 2-tuple
        `proc2` - 2-argument consumer/procedure which can use the expanded tuple elements as arguments
      Returns:
        3-argument consumer/procedure which returns the result value

    - #### concatPred3

          @NotNull
          static <S1,S2,S3,E1,E2> Predicate3<S1,S2,S3> concatPred3(@NotNull
                                                                            Function3<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3> fn1,
                                                                            @NotNull
                                                                            java.util.function.BiPredicate<? super E1,? super E2> pred2)

      Combine a 3-argument function returning a 2-tuple with a 2-parameter predicate into a 3-argument predicate.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `S3` - third argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 3-argument function returning a 2-tuple
        `pred2` - 2-argument predicate which can use the expanded tuple elements as arguments
      Returns:
        3-argument predicate which returns the test result of the tuple returned by `fn1`

    - #### concat4

          @NotNull
          static <S1,S2,S3,S4,E1,E2,R> Function4<R,S1,S2,S3,S4> concat4(@NotNull
                                                                                 Function4<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4> fn1,
                                                                                 @NotNull
                                                                                 java.util.function.BiFunction<? super E1,? super E2,R> fn2)

      Combine a 4-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 4-argument function.
      Type Parameters:
        `S1` - first argument of incoming function `fn1` and returned function
        `S2` - second argument of incoming function `fn1` and returned function
        `S3` - third argument of incoming function `fn1` and returned function
        `S4` - fourth argument of incoming function `fn1` and returned function
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
        `R` - result type
      Parameters:
        `fn1` - 4-argument function returning a 2-tuple
        `fn2` - 2-argument function which can use the expanded tuple elements as arguments and returns the result value
      Returns:
        4-argument function which returns the result value

    - #### concatProc4

          @NotNull
          static <S1,S2,S3,S4,E1,E2> Procedure4<S1,S2,S3,S4> concatProc4(@NotNull
                                                                                  Function4<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4> fn1,
                                                                                  @NotNull
                                                                                  java.util.function.BiConsumer<? super E1,? super E2> proc2)

      Combine a 4-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 4-argument consumer/procedure.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `S3` - third argument of function and returned consumer/procedure
        `S4` - fourth argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 4-argument function returning a 2-tuple
        `proc2` - 2-argument consumer/procedure which can use the expanded tuple elements as arguments
      Returns:
        4-argument consumer/procedure which returns the result value

    - #### concatPred4

          @NotNull
          static <S1,S2,S3,S4,E1,E2> Predicate4<S1,S2,S3,S4> concatPred4(@NotNull
                                                                                  Function4<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4> fn1,
                                                                                  @NotNull
                                                                                  java.util.function.BiPredicate<? super E1,? super E2> pred2)

      Combine a 4-argument function returning a 2-tuple with a 2-parameter predicate into a 4-argument predicate.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `S3` - third argument of function and returned consumer/procedure
        `S4` - fourth argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 4-argument function returning a 2-tuple
        `pred2` - 2-argument predicate which can use the expanded tuple elements as arguments
      Returns:
        4-argument predicate which returns the test result of the tuple returned by `fn1`

    - #### concat5

          @NotNull
          static <S1,S2,S3,S4,S5,E1,E2,R> Function5<R,S1,S2,S3,S4,S5> concat5(@NotNull
                                                                                       Function5<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5> fn1,
                                                                                       @NotNull
                                                                                       java.util.function.BiFunction<? super E1,? super E2,R> fn2)

      Combine a 5-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 5-argument function.
      Type Parameters:
        `S1` - first argument of incoming function `fn1` and returned function
        `S2` - second argument of incoming function `fn1` and returned function
        `S3` - third argument of incoming function `fn1` and returned function
        `S4` - fourth argument of incoming function `fn1` and returned function
        `S5` - fifth argument of incoming function `fn1` and returned function
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
        `R` - result type
      Parameters:
        `fn1` - 5-argument function returning a 2-tuple
        `fn2` - 2-argument function which can use the expanded tuple elements as arguments and returns the result value
      Returns:
        5-argument function which returns the result value

    - #### concatProc5

          @NotNull
          static <S1,S2,S3,S4,S5,E1,E2> Procedure5<S1,S2,S3,S4,S5> concatProc5(@NotNull
                                                                                        Function5<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5> fn1,
                                                                                        @NotNull
                                                                                        java.util.function.BiConsumer<? super E1,? super E2> proc2)

      Combine a 5-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 5-argument consumer/procedure.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `S3` - third argument of function and returned consumer/procedure
        `S4` - fourth argument of function and returned consumer/procedure
        `S5` - fifth argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 5-argument function returning a 2-tuple
        `proc2` - 2-argument consumer/procedure which can use the expanded tuple elements as arguments
      Returns:
        5-argument consumer/procedure which returns the result value

    - #### concatPred5

          @NotNull
          static <S1,S2,S3,S4,S5,E1,E2> Predicate5<S1,S2,S3,S4,S5> concatPred5(@NotNull
                                                                                        Function5<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5> fn1,
                                                                                        @NotNull
                                                                                        java.util.function.BiPredicate<? super E1,? super E2> pred2)

      Combine a 5-argument function returning a 2-tuple with a 2-parameter predicate into a 5-argument predicate.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `S3` - third argument of function and returned consumer/procedure
        `S4` - fourth argument of function and returned consumer/procedure
        `S5` - fifth argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 5-argument function returning a 2-tuple
        `pred2` - 2-argument predicate which can use the expanded tuple elements as arguments
      Returns:
        5-argument predicate which returns the test result of the tuple returned by `fn1`

    - #### concat6

          @NotNull
          static <S1,S2,S3,S4,S5,S6,E1,E2,R> Function6<R,S1,S2,S3,S4,S5,S6> concat6(@NotNull
                                                                                             Function6<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6> fn1,
                                                                                             @NotNull
                                                                                             java.util.function.BiFunction<? super E1,? super E2,R> fn2)

      Combine a 6-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 6-argument function.
      Type Parameters:
        `S1` - first argument of incoming function `fn1` and returned function
        `S2` - second argument of incoming function `fn1` and returned function
        `S3` - third argument of incoming function `fn1` and returned function
        `S4` - fourth argument of incoming function `fn1` and returned function
        `S5` - fifth argument of incoming function `fn1` and returned function
        `S6` - sixth argument of incoming function `fn1` and returned function
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
        `R` - result type
      Parameters:
        `fn1` - 6-argument function returning a 2-tuple
        `fn2` - 2-argument function which can use the expanded tuple elements as arguments and returns the result value
      Returns:
        6-argument function which returns the result value

    - #### concatProc6

          @NotNull
          static <S1,S2,S3,S4,S5,S6,E1,E2> Procedure6<S1,S2,S3,S4,S5,S6> concatProc6(@NotNull
                                                                                              Function6<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6> fn1,
                                                                                              @NotNull
                                                                                              java.util.function.BiConsumer<? super E1,? super E2> proc2)

      Combine a 6-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 6-argument consumer/procedure.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `S3` - third argument of function and returned consumer/procedure
        `S4` - fourth argument of function and returned consumer/procedure
        `S5` - fifth argument of function and returned consumer/procedure
        `S6` - sixth argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 6-argument function returning a 2-tuple
        `proc2` - 2-argument consumer/procedure which can use the expanded tuple elements as arguments
      Returns:
        6-argument consumer/procedure which returns the result value

    - #### concatPred6

          @NotNull
          static <S1,S2,S3,S4,S5,S6,E1,E2> Predicate6<S1,S2,S3,S4,S5,S6> concatPred6(@NotNull
                                                                                              Function6<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6> fn1,
                                                                                              @NotNull
                                                                                              java.util.function.BiPredicate<? super E1,? super E2> pred2)

      Combine a 6-argument function returning a 2-tuple with a 2-parameter predicate into a 6-argument predicate.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `S3` - third argument of function and returned consumer/procedure
        `S4` - fourth argument of function and returned consumer/procedure
        `S5` - fifth argument of function and returned consumer/procedure
        `S6` - sixth argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 6-argument function returning a 2-tuple
        `pred2` - 2-argument predicate which can use the expanded tuple elements as arguments
      Returns:
        6-argument predicate which returns the test result of the tuple returned by `fn1`

    - #### concat7

          @NotNull
          static <S1,S2,S3,S4,S5,S6,S7,E1,E2,R> Function7<R,S1,S2,S3,S4,S5,S6,S7> concat7(@NotNull
                                                                                                   Function7<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6,S7> fn1,
                                                                                                   @NotNull
                                                                                                   java.util.function.BiFunction<? super E1,? super E2,R> fn2)

      Combine a 7-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 7-argument function.
      Type Parameters:
        `S1` - first argument of incoming function `fn1` and returned function
        `S2` - second argument of incoming function `fn1` and returned function
        `S3` - third argument of incoming function `fn1` and returned function
        `S4` - fourth argument of incoming function `fn1` and returned function
        `S5` - fifth argument of incoming function `fn1` and returned function
        `S6` - sixth argument of incoming function `fn1` and returned function
        `S7` - seventh argument of incoming function `fn1` and returned function
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
        `R` - result type
      Parameters:
        `fn1` - 7-argument function returning a 2-tuple
        `fn2` - 2-argument function which can use the expanded tuple elements as arguments and returns the result value
      Returns:
        7-argument function which returns the result value

    - #### concatProc7

          @NotNull
          static <S1,S2,S3,S4,S5,S6,S7,E1,E2> Procedure7<S1,S2,S3,S4,S5,S6,S7> concatProc7(@NotNull
                                                                                                    Function7<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6,S7> fn1,
                                                                                                    @NotNull
                                                                                                    java.util.function.BiConsumer<? super E1,? super E2> proc2)

      Combine a 7-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 7-argument consumer/procedure.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `S3` - third argument of function and returned consumer/procedure
        `S4` - fourth argument of function and returned consumer/procedure
        `S5` - fifth argument of function and returned consumer/procedure
        `S6` - sixth argument of function and returned consumer/procedure
        `S7` - seventh argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 7-argument function returning a 2-tuple
        `proc2` - 2-argument consumer/procedure which can use the expanded tuple elements as arguments
      Returns:
        7-argument consumer/procedure which returns the result value

    - #### concatPred7

          @NotNull
          static <S1,S2,S3,S4,S5,S6,S7,E1,E2> Predicate7<S1,S2,S3,S4,S5,S6,S7> concatPred7(@NotNull
                                                                                                    Function7<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6,S7> fn1,
                                                                                                    @NotNull
                                                                                                    java.util.function.BiPredicate<? super E1,? super E2> pred2)

      Combine a 7-argument function returning a 2-tuple with a 2-parameter predicate into a 7-argument predicate.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `S3` - third argument of function and returned consumer/procedure
        `S4` - fourth argument of function and returned consumer/procedure
        `S5` - fifth argument of function and returned consumer/procedure
        `S6` - sixth argument of function and returned consumer/procedure
        `S7` - seventh argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 7-argument function returning a 2-tuple
        `pred2` - 2-argument predicate which can use the expanded tuple elements as arguments
      Returns:
        7-argument predicate which returns the test result of the tuple returned by `fn1`

    - #### concat8

          @NotNull
          static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,R> Function8<R,S1,S2,S3,S4,S5,S6,S7,S8> concat8(@NotNull
                                                                                                         Function8<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
                                                                                                         @NotNull
                                                                                                         java.util.function.BiFunction<? super E1,? super E2,R> fn2)

      Combine a 8-argument function returning a 2-tuple with a 2-parameter function returning another result value into one 8-argument function.
      Type Parameters:
        `S1` - first argument of incoming function `fn1` and returned function
        `S2` - second argument of incoming function `fn1` and returned function
        `S3` - third argument of incoming function `fn1` and returned function
        `S4` - fourth argument of incoming function `fn1` and returned function
        `S5` - fifth argument of incoming function `fn1` and returned function
        `S6` - sixth argument of incoming function `fn1` and returned function
        `S7` - seventh argument of incoming function `fn1` and returned function
        `S8` - eighth argument of incoming function `fn1` and returned function
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
        `R` - result type
      Parameters:
        `fn1` - 8-argument function returning a 2-tuple
        `fn2` - 2-argument function which can use the expanded tuple elements as arguments and returns the result value
      Returns:
        8-argument function which returns the result value

    - #### concatProc8

          @NotNull
          static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2> Procedure8<S1,S2,S3,S4,S5,S6,S7,S8> concatProc8(@NotNull
                                                                                                          Function8<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
                                                                                                          @NotNull
                                                                                                          java.util.function.BiConsumer<? super E1,? super E2> proc2)

      Combine a 8-argument function returning a 2-tuple with a 2-parameter consumer/procedure into a 8-argument consumer/procedure.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `S3` - third argument of function and returned consumer/procedure
        `S4` - fourth argument of function and returned consumer/procedure
        `S5` - fifth argument of function and returned consumer/procedure
        `S6` - sixth argument of function and returned consumer/procedure
        `S7` - seventh argument of function and returned consumer/procedure
        `S8` - eighth argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 8-argument function returning a 2-tuple
        `proc2` - 2-argument consumer/procedure which can use the expanded tuple elements as arguments
      Returns:
        8-argument consumer/procedure which returns the result value

    - #### concatPred8

          @NotNull
          static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2> Predicate8<S1,S2,S3,S4,S5,S6,S7,S8> concatPred8(@NotNull
                                                                                                          Function8<? extends ITuple2<? extends E1,? extends E2>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
                                                                                                          @NotNull
                                                                                                          java.util.function.BiPredicate<? super E1,? super E2> pred2)

      Combine a 8-argument function returning a 2-tuple with a 2-parameter predicate into a 8-argument predicate.
      Type Parameters:
        `S1` - first argument of function and returned consumer/procedure
        `S2` - second argument of function and returned consumer/procedure
        `S3` - third argument of function and returned consumer/procedure
        `S4` - fourth argument of function and returned consumer/procedure
        `S5` - fifth argument of function and returned consumer/procedure
        `S6` - sixth argument of function and returned consumer/procedure
        `S7` - seventh argument of function and returned consumer/procedure
        `S8` - eighth argument of function and returned consumer/procedure
        `E1` - type of first element of intermediate tuple
        `E2` - type of second element of intermediate tuple
      Parameters:
        `fn1` - 8-argument function returning a 2-tuple
        `pred2` - 2-argument predicate which can use the expanded tuple elements as arguments
      Returns:
        8-argument predicate which returns the test result of the tuple returned by `fn1`