de.caff.generics.tuple

Interface ITuple3<T1,T2,T3>

Type Parameters:

T1 - type of first element

T2 - type of second element

T3 - type of third element

All Known Implementing Classes:

ITuple3.Base, NTuple3, Tuple3

public interface ITuple3<T1,T2,T3>

General interface for immutable 3-tuples.

This is sometimes useful to access either Tuple3 or NTuple3 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(ITuple3) 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:

Tuple3, NTuple3

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	ITuple3.Base<T1,T2,T3> Abstract base implementation of a 3-tuple.

Method Summary

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

_3

T3 _3()

Get the third element.

Returns:

third element

_132

@NotNull
default ITuple3<T1,T3,T2> _132()

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

Returns:

reordered tuple

_312

@NotNull
default ITuple3<T3,T1,T2> _312()

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

Returns:

reordered tuple

_321

@NotNull
default ITuple3<T3,T2,T1> _321()

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

Returns:

reordered tuple

_231

@NotNull
default ITuple3<T2,T3,T1> _231()

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

Returns:

reordered tuple

_213

@NotNull
default ITuple3<T2,T1,T3> _213()

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

Returns:

reordered tuple

_12

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

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

Returns:

reordered tuple

_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

_13

@NotNull
default ITuple2<T1,T3> _13()

Create a new 2-tuple from this one where the elements are ordered: 1st, 3rd.

Returns:

reordered tuple

_31

@NotNull
default ITuple2<T3,T1> _31()

Create a new 2-tuple from this one where the elements are ordered: 3rd, 1st.

Returns:

reordered tuple

_23

@NotNull
default ITuple2<T2,T3> _23()

Create a new 2-tuple from this one where the elements are ordered: 2nd, 3rd.

Returns:

reordered tuple

_32

@NotNull
default ITuple2<T3,T2> _32()

Create a new 2-tuple from this one where the elements are ordered: 3rd, 2nd.

Returns:

reordered tuple

asBase

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

Convert this 3-tuple into a base tuple which provides useful implementations for standard methods.

Returns:

base view of this tuple

frozen

@NotNull
default NTuple3<T1,T2,T3> 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 Tuple3<T1,T2,T3> 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
                     Function3<T,? super T1,? super T2,? super T3> function)

Invoke a %d-argument function on this tuple.

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
                    Procedure3<? super T1,? super T2,? super T3> procedure)

Send this tuple unpacked to a 3-argument procedure.

Parameters:

procedure - procedure called with the unpacked elements of this tuple

testBy

default boolean testBy(@NotNull
                       Predicate3<? super T1,? super T2,? super T3> predicate)

Test a 3-argument predicate with this tuple unpacked.

Parameters:

predicate - predicate called with the unpacked elements of this tuple

Returns:

the predicate's result

view

@NotNull
static <E1,E2,E3> ITuple3<E1,E2,E3> view(E1 elem1,
                                                  E2 elem2,
                                                  E3 elem3)

Create a new 3-tuple on the fly. This is especially useful for temporary usage, you might want to create a Tuple3 instead as that gives guarantees of the non-nullness of its elements, or a NTuple3 as that at least is serializable (as is Tuple3).

Type Parameters:

E1 - type of first element

E2 - type of second element

E3 - type of third element

Parameters:

elem1 - first element of returned tuple

elem2 - second element of returned tuple

elem3 - third element of returned tuple

Returns:

3-tuple view of the given elements

equals

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

Basic implementation of equals for 3-tuples. This can be used in implementations to implement Object.equals(Object). Don't forget hashing: hash(ITuple3)

Parameters:

tuple - tuple to compare

o - other object to compare

Returns:

false if o is null, not a ITuple3, or its members differ
true otherwise

hash

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

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

Parameters:

tuple - tuple to hash

Returns:

hash code

toString

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

Basic implementation for creating a string from a 3-tuple. This one uses "ITuple3" as prefix. This can be used im implementations to implement Object.toString().

Parameters:

tuple - tuple to convert

Returns:

text form

See Also:

toString(String, ITuple3)

toString

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

Basic implementation for creating a string from a 3-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(ITuple3)

concat1

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

Combine a 1-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

R - result type

Parameters:

fn1 - 1-argument function returning a 3-tuple

fn2 - 3-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,E3> java.util.function.Consumer<S1> concatProc1(@NotNull
                                                                          java.util.function.Function<S1,? extends ITuple3<? extends E1,? extends E2,? extends E3>> fn1,
                                                                          @NotNull
                                                                          Procedure3<? super E1,? super E2,? super E3> proc2)

Combine a 1-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 1-argument function returning a 3-tuple

proc2 - 3-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,E3> java.util.function.Predicate<S1> concatPred1(@NotNull
                                                                           java.util.function.Function<S1,? extends ITuple3<? extends E1,? extends E2,? extends E3>> fn1,
                                                                           @NotNull
                                                                           Predicate3<? super E1,? super E2,? super E3> pred2)

Combine a 1-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 1-argument function returning a 3-tuple

pred2 - 3-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,E3,R> java.util.function.BiFunction<S1,S2,R> concat2(@NotNull
                                                                                  java.util.function.BiFunction<S1,S2,? extends ITuple3<? extends E1,? extends E2,? extends E3>> fn1,
                                                                                  @NotNull
                                                                                  Function3<R,? super E1,? super E2,? super E3> fn2)

Combine a 2-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

R - result type

Parameters:

fn1 - 2-argument function returning a 3-tuple

fn2 - 3-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,E3> java.util.function.BiConsumer<S1,S2> concatProc2(@NotNull
                                                                                  java.util.function.BiFunction<S1,S2,? extends ITuple3<? extends E1,? extends E2,? extends E3>> fn1,
                                                                                  @NotNull
                                                                                  Procedure3<? super E1,? super E2,? super E3> proc2)

Combine a 2-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 2-argument function returning a 3-tuple

proc2 - 3-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,E3> java.util.function.BiPredicate<S1,S2> concatPred2(@NotNull
                                                                                   java.util.function.BiFunction<S1,S2,? extends ITuple3<? extends E1,? extends E2,? extends E3>> fn1,
                                                                                   @NotNull
                                                                                   Predicate3<? super E1,? super E2,? super E3> pred2)

Combine a 2-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 2-argument function returning a 3-tuple

pred2 - 3-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,E3,R> Function3<R,S1,S2,S3> concat3(@NotNull
                                                                    Function3<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3> fn1,
                                                                    @NotNull
                                                                    Function3<R,? super E1,? super E2,? super E3> fn2)

Combine a 3-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

R - result type

Parameters:

fn1 - 3-argument function returning a 3-tuple

fn2 - 3-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,E3> Procedure3<S1,S2,S3> concatProc3(@NotNull
                                                                     Function3<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3> fn1,
                                                                     @NotNull
                                                                     Procedure3<? super E1,? super E2,? super E3> proc2)

Combine a 3-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 3-argument function returning a 3-tuple

proc2 - 3-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,E3> Predicate3<S1,S2,S3> concatPred3(@NotNull
                                                                     Function3<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3> fn1,
                                                                     @NotNull
                                                                     Predicate3<? super E1,? super E2,? super E3> pred2)

Combine a 3-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 3-argument function returning a 3-tuple

pred2 - 3-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,E3,R> Function4<R,S1,S2,S3,S4> concat4(@NotNull
                                                                          Function4<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4> fn1,
                                                                          @NotNull
                                                                          Function3<R,? super E1,? super E2,? super E3> fn2)

Combine a 4-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

R - result type

Parameters:

fn1 - 4-argument function returning a 3-tuple

fn2 - 3-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,E3> Procedure4<S1,S2,S3,S4> concatProc4(@NotNull
                                                                           Function4<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4> fn1,
                                                                           @NotNull
                                                                           Procedure3<? super E1,? super E2,? super E3> proc2)

Combine a 4-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 4-argument function returning a 3-tuple

proc2 - 3-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,E3> Predicate4<S1,S2,S3,S4> concatPred4(@NotNull
                                                                           Function4<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4> fn1,
                                                                           @NotNull
                                                                           Predicate3<? super E1,? super E2,? super E3> pred2)

Combine a 4-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 4-argument function returning a 3-tuple

pred2 - 3-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,E3,R> Function5<R,S1,S2,S3,S4,S5> concat5(@NotNull
                                                                                Function5<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4,S5> fn1,
                                                                                @NotNull
                                                                                Function3<R,? super E1,? super E2,? super E3> fn2)

Combine a 5-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

R - result type

Parameters:

fn1 - 5-argument function returning a 3-tuple

fn2 - 3-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,E3> Procedure5<S1,S2,S3,S4,S5> concatProc5(@NotNull
                                                                                 Function5<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4,S5> fn1,
                                                                                 @NotNull
                                                                                 Procedure3<? super E1,? super E2,? super E3> proc2)

Combine a 5-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 5-argument function returning a 3-tuple

proc2 - 3-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,E3> Predicate5<S1,S2,S3,S4,S5> concatPred5(@NotNull
                                                                                 Function5<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4,S5> fn1,
                                                                                 @NotNull
                                                                                 Predicate3<? super E1,? super E2,? super E3> pred2)

Combine a 5-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 5-argument function returning a 3-tuple

pred2 - 3-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,E3,R> Function6<R,S1,S2,S3,S4,S5,S6> concat6(@NotNull
                                                                                      Function6<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4,S5,S6> fn1,
                                                                                      @NotNull
                                                                                      Function3<R,? super E1,? super E2,? super E3> fn2)

Combine a 6-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

R - result type

Parameters:

fn1 - 6-argument function returning a 3-tuple

fn2 - 3-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,E3> Procedure6<S1,S2,S3,S4,S5,S6> concatProc6(@NotNull
                                                                                       Function6<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4,S5,S6> fn1,
                                                                                       @NotNull
                                                                                       Procedure3<? super E1,? super E2,? super E3> proc2)

Combine a 6-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 6-argument function returning a 3-tuple

proc2 - 3-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,E3> Predicate6<S1,S2,S3,S4,S5,S6> concatPred6(@NotNull
                                                                                       Function6<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4,S5,S6> fn1,
                                                                                       @NotNull
                                                                                       Predicate3<? super E1,? super E2,? super E3> pred2)

Combine a 6-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 6-argument function returning a 3-tuple

pred2 - 3-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,E3,R> Function7<R,S1,S2,S3,S4,S5,S6,S7> concat7(@NotNull
                                                                                            Function7<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4,S5,S6,S7> fn1,
                                                                                            @NotNull
                                                                                            Function3<R,? super E1,? super E2,? super E3> fn2)

Combine a 7-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

R - result type

Parameters:

fn1 - 7-argument function returning a 3-tuple

fn2 - 3-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,E3> Procedure7<S1,S2,S3,S4,S5,S6,S7> concatProc7(@NotNull
                                                                                             Function7<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4,S5,S6,S7> fn1,
                                                                                             @NotNull
                                                                                             Procedure3<? super E1,? super E2,? super E3> proc2)

Combine a 7-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 7-argument function returning a 3-tuple

proc2 - 3-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,E3> Predicate7<S1,S2,S3,S4,S5,S6,S7> concatPred7(@NotNull
                                                                                             Function7<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4,S5,S6,S7> fn1,
                                                                                             @NotNull
                                                                                             Predicate3<? super E1,? super E2,? super E3> pred2)

Combine a 7-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 7-argument function returning a 3-tuple

pred2 - 3-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,E3,R> Function8<R,S1,S2,S3,S4,S5,S6,S7,S8> concat8(@NotNull
                                                                                                  Function8<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
                                                                                                  @NotNull
                                                                                                  Function3<R,? super E1,? super E2,? super E3> fn2)

Combine a 8-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

R - result type

Parameters:

fn1 - 8-argument function returning a 3-tuple

fn2 - 3-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,E3> Procedure8<S1,S2,S3,S4,S5,S6,S7,S8> concatProc8(@NotNull
                                                                                                   Function8<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
                                                                                                   @NotNull
                                                                                                   Procedure3<? super E1,? super E2,? super E3> proc2)

Combine a 8-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 8-argument function returning a 3-tuple

proc2 - 3-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,E3> Predicate8<S1,S2,S3,S4,S5,S6,S7,S8> concatPred8(@NotNull
                                                                                                   Function8<? extends ITuple3<? extends E1,? extends E2,? extends E3>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
                                                                                                   @NotNull
                                                                                                   Predicate3<? super E1,? super E2,? super E3> pred2)

Combine a 8-argument function returning a 3-tuple with a 3-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

E3 - type of third element of intermediate tuple

Parameters:

fn1 - 8-argument function returning a 3-tuple

pred2 - 3-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