ITuple2 (CAFF Viewer Class Documentation)

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.

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

Interface ITuple2<T1,T2>

Nested Class Summary

Method Summary

Method Detail

_1

_2

_21

asBase

frozen

frozenNotNull

invoke

sendTo

testBy

view

equals

hash

toString

toString

concat1

concatProc1

concatPred1

concat2

concatProc2

concatPred2

concat3

concatProc3

concatPred3

concat4

concatProc4

concatPred4

concat5

concatProc5

concatPred5

concat6

concatProc6

concatPred6

concat7

concatProc7

concatPred7

concat8

concatProc8

concatPred8