de.caff.generics.tuple

Interface ITuple4<T1,T2,T3,T4>

Type Parameters:

T1 - type of first element

T2 - type of second element

T3 - type of third element

T4 - type of fourth element

All Known Implementing Classes:

ITuple4.Base, NTuple4, Tuple4

public interface ITuple4<T1,T2,T3,T4>

General interface for immutable 4-tuples.

This is sometimes useful to access either Tuple4 or NTuple4 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(ITuple4) 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:

Tuple4, NTuple4

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	ITuple4.Base<T1,T2,T3,T4> Abstract base implementation of a 4-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 ITuple3<T1,T2,T3>	_123() Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 3rd.
default ITuple3<T1,T2,T4>	_124() Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 4th.
default ITuple4<T1,T2,T4,T3>	_1243() Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 3rd.
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.
default ITuple4<T1,T3,T2,T4>	_1324() Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 2nd, 4th.
default ITuple3<T1,T3,T4>	_134() Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 4th.
default ITuple4<T1,T3,T4,T2>	_1342() Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 2nd.
default ITuple2<T1,T4>	_14() Create a new 2-tuple from this one where the elements are ordered: 1st, 4th.
default ITuple3<T1,T4,T2>	_142() Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 2nd.
default ITuple4<T1,T4,T2,T3>	_1423() Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 2nd, 3rd.
default ITuple3<T1,T4,T3>	_143() Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 3rd.
default ITuple4<T1,T4,T3,T2>	_1432() Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 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 ITuple4<T2,T1,T3,T4>	_2134() Create a new 4-tuple from this one where the elements are ordered: 2nd, 1st, 3rd, 4th.
default ITuple3<T2,T1,T4>	_214() Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 4th.
default ITuple4<T2,T1,T4,T3>	_2143() Create a new 4-tuple from this one where the elements are ordered: 2nd, 1st, 4th, 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.
default ITuple4<T2,T3,T1,T4>	_2314() Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 1st, 4th.
default ITuple3<T2,T3,T4>	_234() Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 4th.
default ITuple4<T2,T3,T4,T1>	_2341() Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 1st.
default ITuple2<T2,T4>	_24() Create a new 2-tuple from this one where the elements are ordered: 2nd, 4th.
default ITuple3<T2,T4,T1>	_241() Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 1st.
default ITuple4<T2,T4,T1,T3>	_2413() Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 1st, 3rd.
default ITuple3<T2,T4,T3>	_243() Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 3rd.
default ITuple4<T2,T4,T3,T1>	_2431() Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 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 ITuple4<T3,T1,T2,T4>	_3124() Create a new 4-tuple from this one where the elements are ordered: 3rd, 1st, 2nd, 4th.
default ITuple3<T3,T1,T4>	_314() Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 4th.
default ITuple4<T3,T1,T4,T2>	_3142() Create a new 4-tuple from this one where the elements are ordered: 3rd, 1st, 4th, 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 ITuple4<T3,T2,T1,T4>	_3214() Create a new 4-tuple from this one where the elements are ordered: 3rd, 2nd, 1st, 4th.
default ITuple3<T3,T2,T4>	_324() Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 4th.
default ITuple4<T3,T2,T4,T1>	_3241() Create a new 4-tuple from this one where the elements are ordered: 3rd, 2nd, 4th, 1st.
default ITuple2<T3,T4>	_34() Create a new 2-tuple from this one where the elements are ordered: 3rd, 4th.
default ITuple3<T3,T4,T1>	_341() Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 1st.
default ITuple4<T3,T4,T1,T2>	_3412() Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 1st, 2nd.
default ITuple3<T3,T4,T2>	_342() Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 2nd.
default ITuple4<T3,T4,T2,T1>	_3421() Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 2nd, 1st.
T4	_4() Get the fourth element.
default ITuple2<T4,T1>	_41() Create a new 2-tuple from this one where the elements are ordered: 4th, 1st.
default ITuple3<T4,T1,T2>	_412() Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 2nd.
default ITuple4<T4,T1,T2,T3>	_4123() Create a new 4-tuple from this one where the elements are ordered: 4th, 1st, 2nd, 3rd.
default ITuple3<T4,T1,T3>	_413() Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 3rd.
default ITuple4<T4,T1,T3,T2>	_4132() Create a new 4-tuple from this one where the elements are ordered: 4th, 1st, 3rd, 2nd.
default ITuple2<T4,T2>	_42() Create a new 2-tuple from this one where the elements are ordered: 4th, 2nd.
default ITuple3<T4,T2,T1>	_421() Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 1st.
default ITuple4<T4,T2,T1,T3>	_4213() Create a new 4-tuple from this one where the elements are ordered: 4th, 2nd, 1st, 3rd.
default ITuple3<T4,T2,T3>	_423() Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 3rd.
default ITuple4<T4,T2,T3,T1>	_4231() Create a new 4-tuple from this one where the elements are ordered: 4th, 2nd, 3rd, 1st.
default ITuple2<T4,T3>	_43() Create a new 2-tuple from this one where the elements are ordered: 4th, 3rd.
default ITuple3<T4,T3,T1>	_431() Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 1st.
default ITuple4<T4,T3,T1,T2>	_4312() Create a new 4-tuple from this one where the elements are ordered: 4th, 3rd, 1st, 2nd.
default ITuple3<T4,T3,T2>	_432() Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 2nd.
default ITuple4<T4,T3,T2,T1>	_4321() Create a new 4-tuple from this one where the elements are ordered: 4th, 3rd, 2nd, 1st.
default ITuple4.Base<T1,T2,T3,T4>	asBase() Convert this 4-tuple into a base tuple which provides useful implementations for standard methods.
static <S1,E1,E2,E3,E4,R> java.util.function.Function<S1,R>	concat1(java.util.function.Function<S1,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1, Function4<R,? super E1,? super E2,? super E3,? super E4> fn2) Combine a 1-argument function returning a 4-tuple with a 4-parameter function returning another result value into one 1-argument function.
static <S1,S2,E1,E2,E3,E4,R> java.util.function.BiFunction<S1,S2,R>	concat2(java.util.function.BiFunction<S1,S2,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1, Function4<R,? super E1,? super E2,? super E3,? super E4> fn2) Combine a 2-argument function returning a 4-tuple with a 4-parameter function returning another result value into one 2-argument function.
static <S1,S2,S3,E1,E2,E3,E4,R> Function3<R,S1,S2,S3>	concat3(Function3<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3> fn1, Function4<R,? super E1,? super E2,? super E3,? super E4> fn2) Combine a 3-argument function returning a 4-tuple with a 4-parameter function returning another result value into one 3-argument function.
static <S1,S2,S3,S4,E1,E2,E3,E4,R> Function4<R,S1,S2,S3,S4>	concat4(Function4<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4> fn1, Function4<R,? super E1,? super E2,? super E3,? super E4> fn2) Combine a 4-argument function returning a 4-tuple with a 4-parameter function returning another result value into one 4-argument function.
static <S1,S2,S3,S4,S5,E1,E2,E3,E4,R> Function5<R,S1,S2,S3,S4,S5>	concat5(Function5<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5> fn1, Function4<R,? super E1,? super E2,? super E3,? super E4> fn2) Combine a 5-argument function returning a 4-tuple with a 4-parameter function returning another result value into one 5-argument function.
static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4,R> Function6<R,S1,S2,S3,S4,S5,S6>	concat6(Function6<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6> fn1, Function4<R,? super E1,? super E2,? super E3,? super E4> fn2) Combine a 6-argument function returning a 4-tuple with a 4-parameter function returning another result value into one 6-argument function.
static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4,R> Function7<R,S1,S2,S3,S4,S5,S6,S7>	concat7(Function7<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7> fn1, Function4<R,? super E1,? super E2,? super E3,? super E4> fn2) Combine a 7-argument function returning a 4-tuple with a 4-parameter function returning another result value into one 7-argument function.
static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4,R> Function8<R,S1,S2,S3,S4,S5,S6,S7,S8>	concat8(Function8<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, Function4<R,? super E1,? super E2,? super E3,? super E4> fn2) Combine a 8-argument function returning a 4-tuple with a 4-parameter function returning another result value into one 8-argument function.
static <S1,E1,E2,E3,E4> java.util.function.Predicate<S1>	concatPred1(java.util.function.Function<S1,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1, Predicate4<? super E1,? super E2,? super E3,? super E4> pred2) Combine a 1-argument function returning a 4-tuple with a 4-parameter predicate into a 1-argument predicate.
static <S1,S2,E1,E2,E3,E4> java.util.function.BiPredicate<S1,S2>	concatPred2(java.util.function.BiFunction<S1,S2,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1, Predicate4<? super E1,? super E2,? super E3,? super E4> pred2) Combine a 2-argument function returning a 4-tuple with a 4-parameter predicate into a 2-argument predicate.
static <S1,S2,S3,E1,E2,E3,E4> Predicate3<S1,S2,S3>	concatPred3(Function3<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3> fn1, Predicate4<? super E1,? super E2,? super E3,? super E4> pred2) Combine a 3-argument function returning a 4-tuple with a 4-parameter predicate into a 3-argument predicate.
static <S1,S2,S3,S4,E1,E2,E3,E4> Predicate4<S1,S2,S3,S4>	concatPred4(Function4<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4> fn1, Predicate4<? super E1,? super E2,? super E3,? super E4> pred2) Combine a 4-argument function returning a 4-tuple with a 4-parameter predicate into a 4-argument predicate.
static <S1,S2,S3,S4,S5,E1,E2,E3,E4> Predicate5<S1,S2,S3,S4,S5>	concatPred5(Function5<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5> fn1, Predicate4<? super E1,? super E2,? super E3,? super E4> pred2) Combine a 5-argument function returning a 4-tuple with a 4-parameter predicate into a 5-argument predicate.
static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4> Predicate6<S1,S2,S3,S4,S5,S6>	concatPred6(Function6<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6> fn1, Predicate4<? super E1,? super E2,? super E3,? super E4> pred2) Combine a 6-argument function returning a 4-tuple with a 4-parameter predicate into a 6-argument predicate.
static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4> Predicate7<S1,S2,S3,S4,S5,S6,S7>	concatPred7(Function7<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7> fn1, Predicate4<? super E1,? super E2,? super E3,? super E4> pred2) Combine a 7-argument function returning a 4-tuple with a 4-parameter predicate into a 7-argument predicate.
static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4> Predicate8<S1,S2,S3,S4,S5,S6,S7,S8>	concatPred8(Function8<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, Predicate4<? super E1,? super E2,? super E3,? super E4> pred2) Combine a 8-argument function returning a 4-tuple with a 4-parameter predicate into a 8-argument predicate.
static <S1,E1,E2,E3,E4> java.util.function.Consumer<S1>	concatProc1(java.util.function.Function<S1,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1, Procedure4<? super E1,? super E2,? super E3,? super E4> proc2) Combine a 1-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 1-argument consumer/procedure.
static <S1,S2,E1,E2,E3,E4> java.util.function.BiConsumer<S1,S2>	concatProc2(java.util.function.BiFunction<S1,S2,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1, Procedure4<? super E1,? super E2,? super E3,? super E4> proc2) Combine a 2-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 2-argument consumer/procedure.
static <S1,S2,S3,E1,E2,E3,E4> Procedure3<S1,S2,S3>	concatProc3(Function3<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3> fn1, Procedure4<? super E1,? super E2,? super E3,? super E4> proc2) Combine a 3-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 3-argument consumer/procedure.
static <S1,S2,S3,S4,E1,E2,E3,E4> Procedure4<S1,S2,S3,S4>	concatProc4(Function4<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4> fn1, Procedure4<? super E1,? super E2,? super E3,? super E4> proc2) Combine a 4-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 4-argument consumer/procedure.
static <S1,S2,S3,S4,S5,E1,E2,E3,E4> Procedure5<S1,S2,S3,S4,S5>	concatProc5(Function5<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5> fn1, Procedure4<? super E1,? super E2,? super E3,? super E4> proc2) Combine a 5-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 5-argument consumer/procedure.
static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4> Procedure6<S1,S2,S3,S4,S5,S6>	concatProc6(Function6<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6> fn1, Procedure4<? super E1,? super E2,? super E3,? super E4> proc2) Combine a 6-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 6-argument consumer/procedure.
static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4> Procedure7<S1,S2,S3,S4,S5,S6,S7>	concatProc7(Function7<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7> fn1, Procedure4<? super E1,? super E2,? super E3,? super E4> proc2) Combine a 7-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 7-argument consumer/procedure.
static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4> Procedure8<S1,S2,S3,S4,S5,S6,S7,S8>	concatProc8(Function8<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, Procedure4<? super E1,? super E2,? super E3,? super E4> proc2) Combine a 8-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 8-argument consumer/procedure.
static boolean	equals(ITuple4<?,?,?,?> tuple, java.lang.Object o) Basic implementation of equals for 4-tuples.
default NTuple4<T1,T2,T3,T4>	frozen() Convert this into an object of a concrete tuple implementation.
default Tuple4<T1,T2,T3,T4>	frozenNotNull() Convert this into an object of a concrete tuple implementation.
static int	hash(ITuple4<?,?,?,?> tuple) Basic implementation for calculating a hash code of a 4-tuple.
default <T> T	invoke(Function4<T,? super T1,? super T2,? super T3,? super T4> function) Invoke a %d-argument function on this tuple.
default void	sendTo(Procedure4<? super T1,? super T2,? super T3,? super T4> procedure) Send this tuple unpacked to a 4-argument procedure.
default boolean	testBy(Predicate4<? super T1,? super T2,? super T3,? super T4> predicate) Test a 4-argument predicate with this tuple unpacked.
static java.lang.String	toString(ITuple4<?,?,?,?> tuple) Basic implementation for creating a string from a 4-tuple.
static java.lang.String	toString(java.lang.String prefix, ITuple4<?,?,?,?> tuple) Basic implementation for creating a string from a 4-tuple.
static <E1,E2,E3,E4> ITuple4<E1,E2,E3,E4>	view(E1 elem1, E2 elem2, E3 elem3, E4 elem4) Create a new 4-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

_4

T4 _4()

Get the fourth element.

Returns:

fourth element

_1243

@NotNull
default ITuple4<T1,T2,T4,T3> _1243()

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

Returns:

reordered tuple

_1423

@NotNull
default ITuple4<T1,T4,T2,T3> _1423()

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

Returns:

reordered tuple

_4123

@NotNull
default ITuple4<T4,T1,T2,T3> _4123()

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

Returns:

reordered tuple

_4132

@NotNull
default ITuple4<T4,T1,T3,T2> _4132()

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

Returns:

reordered tuple

_1432

@NotNull
default ITuple4<T1,T4,T3,T2> _1432()

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

Returns:

reordered tuple

_1342

@NotNull
default ITuple4<T1,T3,T4,T2> _1342()

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

Returns:

reordered tuple

_1324

@NotNull
default ITuple4<T1,T3,T2,T4> _1324()

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

Returns:

reordered tuple

_3124

@NotNull
default ITuple4<T3,T1,T2,T4> _3124()

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

Returns:

reordered tuple

_3142

@NotNull
default ITuple4<T3,T1,T4,T2> _3142()

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

Returns:

reordered tuple

_3412

@NotNull
default ITuple4<T3,T4,T1,T2> _3412()

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

Returns:

reordered tuple

_4312

@NotNull
default ITuple4<T4,T3,T1,T2> _4312()

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

Returns:

reordered tuple

_4321

@NotNull
default ITuple4<T4,T3,T2,T1> _4321()

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

Returns:

reordered tuple

_3421

@NotNull
default ITuple4<T3,T4,T2,T1> _3421()

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

Returns:

reordered tuple

_3241

@NotNull
default ITuple4<T3,T2,T4,T1> _3241()

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

Returns:

reordered tuple

_3214

@NotNull
default ITuple4<T3,T2,T1,T4> _3214()

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

Returns:

reordered tuple

_2314

@NotNull
default ITuple4<T2,T3,T1,T4> _2314()

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

Returns:

reordered tuple

_2341

@NotNull
default ITuple4<T2,T3,T4,T1> _2341()

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

Returns:

reordered tuple

_2431

@NotNull
default ITuple4<T2,T4,T3,T1> _2431()

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

Returns:

reordered tuple

_4231

@NotNull
default ITuple4<T4,T2,T3,T1> _4231()

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

Returns:

reordered tuple

_4213

@NotNull
default ITuple4<T4,T2,T1,T3> _4213()

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

Returns:

reordered tuple

_2413

@NotNull
default ITuple4<T2,T4,T1,T3> _2413()

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

Returns:

reordered tuple

_2143

@NotNull
default ITuple4<T2,T1,T4,T3> _2143()

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

Returns:

reordered tuple

_2134

@NotNull
default ITuple4<T2,T1,T3,T4> _2134()

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

Returns:

reordered tuple

_123

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

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

Returns:

reordered tuple

_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

_124

@NotNull
default ITuple3<T1,T2,T4> _124()

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

Returns:

reordered tuple

_142

@NotNull
default ITuple3<T1,T4,T2> _142()

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

Returns:

reordered tuple

_412

@NotNull
default ITuple3<T4,T1,T2> _412()

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

Returns:

reordered tuple

_421

@NotNull
default ITuple3<T4,T2,T1> _421()

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

Returns:

reordered tuple

_241

@NotNull
default ITuple3<T2,T4,T1> _241()

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

Returns:

reordered tuple

_214

@NotNull
default ITuple3<T2,T1,T4> _214()

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

Returns:

reordered tuple

_134

@NotNull
default ITuple3<T1,T3,T4> _134()

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

Returns:

reordered tuple

_143

@NotNull
default ITuple3<T1,T4,T3> _143()

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

Returns:

reordered tuple

_413

@NotNull
default ITuple3<T4,T1,T3> _413()

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

Returns:

reordered tuple

_431

@NotNull
default ITuple3<T4,T3,T1> _431()

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

Returns:

reordered tuple

_341

@NotNull
default ITuple3<T3,T4,T1> _341()

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

Returns:

reordered tuple

_314

@NotNull
default ITuple3<T3,T1,T4> _314()

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

Returns:

reordered tuple

_234

@NotNull
default ITuple3<T2,T3,T4> _234()

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

Returns:

reordered tuple

_243

@NotNull
default ITuple3<T2,T4,T3> _243()

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

Returns:

reordered tuple

_423

@NotNull
default ITuple3<T4,T2,T3> _423()

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

Returns:

reordered tuple

_432

@NotNull
default ITuple3<T4,T3,T2> _432()

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

Returns:

reordered tuple

_342

@NotNull
default ITuple3<T3,T4,T2> _342()

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

Returns:

reordered tuple

_324

@NotNull
default ITuple3<T3,T2,T4> _324()

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

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

_14

@NotNull
default ITuple2<T1,T4> _14()

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

Returns:

reordered tuple

_41

@NotNull
default ITuple2<T4,T1> _41()

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

Returns:

reordered tuple

_24

@NotNull
default ITuple2<T2,T4> _24()

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

Returns:

reordered tuple

_42

@NotNull
default ITuple2<T4,T2> _42()

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

Returns:

reordered tuple

_34

@NotNull
default ITuple2<T3,T4> _34()

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

Returns:

reordered tuple

_43

@NotNull
default ITuple2<T4,T3> _43()

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

Returns:

reordered tuple

asBase

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

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

Returns:

base view of this tuple

frozen

@NotNull
default NTuple4<T1,T2,T3,T4> 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 Tuple4<T1,T2,T3,T4> 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
                     Function4<T,? super T1,? super T2,? super T3,? super T4> 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
                    Procedure4<? super T1,? super T2,? super T3,? super T4> procedure)

Send this tuple unpacked to a 4-argument procedure.

Parameters:

procedure - procedure called with the unpacked elements of this tuple

testBy

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

Test a 4-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,E4> ITuple4<E1,E2,E3,E4> view(E1 elem1,
                                                        E2 elem2,
                                                        E3 elem3,
                                                        E4 elem4)

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

Type Parameters:

E1 - type of first element

E2 - type of second element

E3 - type of third element

E4 - type of fourth element

Parameters:

elem1 - first element of returned tuple

elem2 - second element of returned tuple

elem3 - third element of returned tuple

elem4 - fourth element of returned tuple

Returns:

4-tuple view of the given elements

equals

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

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

Parameters:

tuple - tuple to compare

o - other object to compare

Returns:

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

hash

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

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

Parameters:

tuple - tuple to hash

Returns:

hash code

toString

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

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

Parameters:

tuple - tuple to convert

Returns:

text form

See Also:

toString(String, ITuple4)

toString

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

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

concat1

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

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

E4 - type of fourth element of intermediate tuple

R - result type

Parameters:

fn1 - 1-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 1-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 1-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

R - result type

Parameters:

fn1 - 2-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 2-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 2-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

R - result type

Parameters:

fn1 - 3-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 3-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 3-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

R - result type

Parameters:

fn1 - 4-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 4-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 4-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

R - result type

Parameters:

fn1 - 5-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 5-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 5-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

R - result type

Parameters:

fn1 - 6-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 6-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 6-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

R - result type

Parameters:

fn1 - 7-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 7-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 7-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

R - result type

Parameters:

fn1 - 8-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 8-argument function returning a 4-tuple

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

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

E4 - type of fourth element of intermediate tuple

Parameters:

fn1 - 8-argument function returning a 4-tuple

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