ITuple6 (CAFF Viewer Class Documentation)

Type Parameters:

T1 - type of first element

T2 - type of second element

T3 - type of third element

T4 - type of fourth element

T5 - type of fifth element

T6 - type of sixth element

All Known Implementing Classes:

ITuple6.Base, NTuple6, Tuple6
```
public interface ITuple6<T1,T2,T3,T4,T5,T6>
```
General interface for immutable 6-tuples.
This is sometimes useful to access either Tuple6 or NTuple6 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(ITuple6) 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:

Tuple6, NTuple6

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class ITuple6.Base<T1,T2,T3,T4,T5,T6>
Abstract base implementation of a 6-tuple.

Nested Classes
Modifier and Type	Interface and Description
`static class`	`ITuple6.Base<T1,T2,T3,T4,T5,T6>` Abstract base implementation of a 6-tuple.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`T1`	`_1()` Get the first element.
`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 ITuple4<T1,T2,T3,T4>`	`_1234()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 4th.
`default ITuple5<T1,T2,T3,T4,T5>`	`_12345()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 4th, 5th.
`default ITuple5<T1,T2,T3,T4,T6>`	`_12346()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 4th, 6th.
`default ITuple4<T1,T2,T3,T5>`	`_1235()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 5th.
`default ITuple5<T1,T2,T3,T5,T6>`	`_12356()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 5th, 6th.
`default ITuple4<T1,T2,T3,T6>`	`_1236()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 6th.
`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,T5>`	`_1245()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 5th.
`default ITuple5<T1,T2,T4,T5,T6>`	`_12456()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 5th, 6th.
`default ITuple4<T1,T2,T4,T6>`	`_1246()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 6th.
`default ITuple3<T1,T2,T5>`	`_125()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 5th.
`default ITuple4<T1,T2,T5,T6>`	`_1256()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 5th, 6th.
`default ITuple3<T1,T2,T6>`	`_126()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 6th.
`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 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,T5>`	`_1345()` Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 5th.
`default ITuple5<T1,T3,T4,T5,T6>`	`_13456()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 5th, 6th.
`default ITuple4<T1,T3,T4,T6>`	`_1346()` Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 6th.
`default ITuple3<T1,T3,T5>`	`_135()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 5th.
`default ITuple4<T1,T3,T5,T6>`	`_1356()` Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 5th, 6th.
`default ITuple3<T1,T3,T6>`	`_136()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 6th.
`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 ITuple3<T1,T4,T3>`	`_143()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 3rd.
`default ITuple3<T1,T4,T5>`	`_145()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 5th.
`default ITuple4<T1,T4,T5,T6>`	`_1456()` Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 5th, 6th.
`default ITuple3<T1,T4,T6>`	`_146()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 6th.
`default ITuple2<T1,T5>`	`_15()` Create a new 2-tuple from this one where the elements are ordered: 1st, 5th.
`default ITuple3<T1,T5,T2>`	`_152()` Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 2nd.
`default ITuple3<T1,T5,T3>`	`_153()` Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 3rd.
`default ITuple3<T1,T5,T4>`	`_154()` Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 4th.
`default ITuple3<T1,T5,T6>`	`_156()` Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 6th.
`default ITuple2<T1,T6>`	`_16()` Create a new 2-tuple from this one where the elements are ordered: 1st, 6th.
`default ITuple3<T1,T6,T2>`	`_162()` Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 2nd.
`default ITuple3<T1,T6,T3>`	`_163()` Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 3rd.
`default ITuple3<T1,T6,T4>`	`_164()` Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 4th.
`default ITuple3<T1,T6,T5>`	`_165()` Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 5th.
`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 ITuple3<T2,T1,T4>`	`_214()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 4th.
`default ITuple3<T2,T1,T5>`	`_215()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 5th.
`default ITuple3<T2,T1,T6>`	`_216()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 6th.
`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 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,T5>`	`_2345()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 5th.
`default ITuple5<T2,T3,T4,T5,T6>`	`_23456()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 5th, 6th.
`default ITuple4<T2,T3,T4,T6>`	`_2346()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 6th.
`default ITuple3<T2,T3,T5>`	`_235()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 5th.
`default ITuple4<T2,T3,T5,T6>`	`_2356()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 5th, 6th.
`default ITuple3<T2,T3,T6>`	`_236()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 6th.
`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 ITuple3<T2,T4,T3>`	`_243()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 3rd.
`default ITuple3<T2,T4,T5>`	`_245()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 5th.
`default ITuple4<T2,T4,T5,T6>`	`_2456()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 5th, 6th.
`default ITuple3<T2,T4,T6>`	`_246()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 6th.
`default ITuple2<T2,T5>`	`_25()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 5th.
`default ITuple3<T2,T5,T1>`	`_251()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 1st.
`default ITuple3<T2,T5,T3>`	`_253()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 3rd.
`default ITuple3<T2,T5,T4>`	`_254()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 4th.
`default ITuple3<T2,T5,T6>`	`_256()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 6th.
`default ITuple2<T2,T6>`	`_26()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 6th.
`default ITuple3<T2,T6,T1>`	`_261()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 1st.
`default ITuple3<T2,T6,T3>`	`_263()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 3rd.
`default ITuple3<T2,T6,T4>`	`_264()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 4th.
`default ITuple3<T2,T6,T5>`	`_265()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 5th.
`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 ITuple3<T3,T1,T4>`	`_314()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 4th.
`default ITuple3<T3,T1,T5>`	`_315()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 5th.
`default ITuple3<T3,T1,T6>`	`_316()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 6th.
`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<T3,T2,T4>`	`_324()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 4th.
`default ITuple3<T3,T2,T5>`	`_325()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 5th.
`default ITuple3<T3,T2,T6>`	`_326()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 6th.
`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 ITuple3<T3,T4,T2>`	`_342()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 2nd.
`default ITuple3<T3,T4,T5>`	`_345()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 5th.
`default ITuple4<T3,T4,T5,T6>`	`_3456()` Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 5th, 6th.
`default ITuple3<T3,T4,T6>`	`_346()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 6th.
`default ITuple2<T3,T5>`	`_35()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 5th.
`default ITuple3<T3,T5,T1>`	`_351()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 1st.
`default ITuple3<T3,T5,T2>`	`_352()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 2nd.
`default ITuple3<T3,T5,T4>`	`_354()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 4th.
`default ITuple3<T3,T5,T6>`	`_356()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 6th.
`default ITuple2<T3,T6>`	`_36()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 6th.
`default ITuple3<T3,T6,T1>`	`_361()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 1st.
`default ITuple3<T3,T6,T2>`	`_362()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 2nd.
`default ITuple3<T3,T6,T4>`	`_364()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 4th.
`default ITuple3<T3,T6,T5>`	`_365()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 5th.
`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 ITuple3<T4,T1,T3>`	`_413()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 3rd.
`default ITuple3<T4,T1,T5>`	`_415()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 5th.
`default ITuple3<T4,T1,T6>`	`_416()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 6th.
`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 ITuple3<T4,T2,T3>`	`_423()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 3rd.
`default ITuple3<T4,T2,T5>`	`_425()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 5th.
`default ITuple3<T4,T2,T6>`	`_426()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 6th.
`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 ITuple3<T4,T3,T2>`	`_432()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 2nd.
`default ITuple3<T4,T3,T5>`	`_435()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 5th.
`default ITuple3<T4,T3,T6>`	`_436()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 6th.
`default ITuple2<T4,T5>`	`_45()` Create a new 2-tuple from this one where the elements are ordered: 4th, 5th.
`default ITuple3<T4,T5,T1>`	`_451()` Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 1st.
`default ITuple3<T4,T5,T2>`	`_452()` Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 2nd.
`default ITuple3<T4,T5,T3>`	`_453()` Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 3rd.
`default ITuple3<T4,T5,T6>`	`_456()` Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 6th.
`default ITuple2<T4,T6>`	`_46()` Create a new 2-tuple from this one where the elements are ordered: 4th, 6th.
`default ITuple3<T4,T6,T1>`	`_461()` Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 1st.
`default ITuple3<T4,T6,T2>`	`_462()` Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 2nd.
`default ITuple3<T4,T6,T3>`	`_463()` Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 3rd.
`default ITuple3<T4,T6,T5>`	`_465()` Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 5th.
`T5`	`_5()` Get the fifth element.
`default ITuple2<T5,T1>`	`_51()` Create a new 2-tuple from this one where the elements are ordered: 5th, 1st.
`default ITuple3<T5,T1,T2>`	`_512()` Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 2nd.
`default ITuple3<T5,T1,T3>`	`_513()` Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 3rd.
`default ITuple3<T5,T1,T4>`	`_514()` Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 4th.
`default ITuple3<T5,T1,T6>`	`_516()` Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 6th.
`default ITuple2<T5,T2>`	`_52()` Create a new 2-tuple from this one where the elements are ordered: 5th, 2nd.
`default ITuple3<T5,T2,T1>`	`_521()` Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 1st.
`default ITuple3<T5,T2,T3>`	`_523()` Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 3rd.
`default ITuple3<T5,T2,T4>`	`_524()` Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 4th.
`default ITuple3<T5,T2,T6>`	`_526()` Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 6th.
`default ITuple2<T5,T3>`	`_53()` Create a new 2-tuple from this one where the elements are ordered: 5th, 3rd.
`default ITuple3<T5,T3,T1>`	`_531()` Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 1st.
`default ITuple3<T5,T3,T2>`	`_532()` Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 2nd.
`default ITuple3<T5,T3,T4>`	`_534()` Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 4th.
`default ITuple3<T5,T3,T6>`	`_536()` Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 6th.
`default ITuple2<T5,T4>`	`_54()` Create a new 2-tuple from this one where the elements are ordered: 5th, 4th.
`default ITuple3<T5,T4,T1>`	`_541()` Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 1st.
`default ITuple3<T5,T4,T2>`	`_542()` Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 2nd.
`default ITuple3<T5,T4,T3>`	`_543()` Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 3rd.
`default ITuple3<T5,T4,T6>`	`_546()` Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 6th.
`default ITuple2<T5,T6>`	`_56()` Create a new 2-tuple from this one where the elements are ordered: 5th, 6th.
`default ITuple3<T5,T6,T1>`	`_561()` Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 1st.
`default ITuple3<T5,T6,T2>`	`_562()` Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 2nd.
`default ITuple3<T5,T6,T3>`	`_563()` Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 3rd.
`default ITuple3<T5,T6,T4>`	`_564()` Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 4th.
`T6`	`_6()` Get the sixth element.
`default ITuple2<T6,T1>`	`_61()` Create a new 2-tuple from this one where the elements are ordered: 6th, 1st.
`default ITuple3<T6,T1,T2>`	`_612()` Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 2nd.
`default ITuple3<T6,T1,T3>`	`_613()` Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 3rd.
`default ITuple3<T6,T1,T4>`	`_614()` Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 4th.
`default ITuple3<T6,T1,T5>`	`_615()` Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 5th.
`default ITuple2<T6,T2>`	`_62()` Create a new 2-tuple from this one where the elements are ordered: 6th, 2nd.
`default ITuple3<T6,T2,T1>`	`_621()` Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 1st.
`default ITuple3<T6,T2,T3>`	`_623()` Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 3rd.
`default ITuple3<T6,T2,T4>`	`_624()` Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 4th.
`default ITuple3<T6,T2,T5>`	`_625()` Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 5th.
`default ITuple2<T6,T3>`	`_63()` Create a new 2-tuple from this one where the elements are ordered: 6th, 3rd.
`default ITuple3<T6,T3,T1>`	`_631()` Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 1st.
`default ITuple3<T6,T3,T2>`	`_632()` Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 2nd.
`default ITuple3<T6,T3,T4>`	`_634()` Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 4th.
`default ITuple3<T6,T3,T5>`	`_635()` Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 5th.
`default ITuple2<T6,T4>`	`_64()` Create a new 2-tuple from this one where the elements are ordered: 6th, 4th.
`default ITuple3<T6,T4,T1>`	`_641()` Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 1st.
`default ITuple3<T6,T4,T2>`	`_642()` Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 2nd.
`default ITuple3<T6,T4,T3>`	`_643()` Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 3rd.
`default ITuple3<T6,T4,T5>`	`_645()` Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 5th.
`default ITuple2<T6,T5>`	`_65()` Create a new 2-tuple from this one where the elements are ordered: 6th, 5th.
`default ITuple3<T6,T5,T1>`	`_651()` Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 1st.
`default ITuple3<T6,T5,T2>`	`_652()` Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 2nd.
`default ITuple3<T6,T5,T3>`	`_653()` Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 3rd.
`default ITuple3<T6,T5,T4>`	`_654()` Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 4th.
`default ITuple6.Base<T1,T2,T3,T4,T5,T6>`	`asBase()` Convert this 6-tuple into a `base tuple` which provides useful implementations for standard methods.
`static <S1,E1,E2,E3,E4,E5,E6,R> java.util.function.Function<S1,R>`	`concat1(java.util.function.Function<S1,? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>> fn1, Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)` Combine a 1-argument function returning a 6-tuple with a 6-parameter function returning another result value into one 1-argument function.
`static <S1,S2,E1,E2,E3,E4,E5,E6,R> java.util.function.BiFunction<S1,S2,R>`	`concat2(java.util.function.BiFunction<S1,S2,? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>> fn1, Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)` Combine a 2-argument function returning a 6-tuple with a 6-parameter function returning another result value into one 2-argument function.
`static <S1,S2,S3,E1,E2,E3,E4,E5,E6,R> Function3<R,S1,S2,S3>`	`concat3(Function3<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3> fn1, Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)` Combine a 3-argument function returning a 6-tuple with a 6-parameter function returning another result value into one 3-argument function.
`static <S1,S2,S3,S4,E1,E2,E3,E4,E5,E6,R> Function4<R,S1,S2,S3,S4>`	`concat4(Function4<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4> fn1, Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)` Combine a 4-argument function returning a 6-tuple with a 6-parameter function returning another result value into one 4-argument function.
`static <S1,S2,S3,S4,S5,E1,E2,E3,E4,E5,E6,R> Function5<R,S1,S2,S3,S4,S5>`	`concat5(Function5<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5> fn1, Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)` Combine a 5-argument function returning a 6-tuple with a 6-parameter function returning another result value into one 5-argument function.
`static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4,E5,E6,R> Function6<R,S1,S2,S3,S4,S5,S6>`	`concat6(Function6<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6> fn1, Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)` Combine a 6-argument function returning a 6-tuple with a 6-parameter function returning another result value into one 6-argument function.
`static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4,E5,E6,R> Function7<R,S1,S2,S3,S4,S5,S6,S7>`	`concat7(Function7<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6,S7> fn1, Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)` Combine a 7-argument function returning a 6-tuple with a 6-parameter function returning another result value into one 7-argument function.
`static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4,E5,E6,R> Function8<R,S1,S2,S3,S4,S5,S6,S7,S8>`	`concat8(Function8<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)` Combine a 8-argument function returning a 6-tuple with a 6-parameter function returning another result value into one 8-argument function.
`static <S1,E1,E2,E3,E4,E5,E6> java.util.function.Predicate<S1>`	`concatPred1(java.util.function.Function<S1,? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>> fn1, Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)` Combine a 1-argument function returning a 6-tuple with a 6-parameter predicate into a 1-argument predicate.
`static <S1,S2,E1,E2,E3,E4,E5,E6> java.util.function.BiPredicate<S1,S2>`	`concatPred2(java.util.function.BiFunction<S1,S2,? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>> fn1, Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)` Combine a 2-argument function returning a 6-tuple with a 6-parameter predicate into a 2-argument predicate.
`static <S1,S2,S3,E1,E2,E3,E4,E5,E6> Predicate3<S1,S2,S3>`	`concatPred3(Function3<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3> fn1, Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)` Combine a 3-argument function returning a 6-tuple with a 6-parameter predicate into a 3-argument predicate.
`static <S1,S2,S3,S4,E1,E2,E3,E4,E5,E6> Predicate4<S1,S2,S3,S4>`	`concatPred4(Function4<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4> fn1, Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)` Combine a 4-argument function returning a 6-tuple with a 6-parameter predicate into a 4-argument predicate.
`static <S1,S2,S3,S4,S5,E1,E2,E3,E4,E5,E6> Predicate5<S1,S2,S3,S4,S5>`	`concatPred5(Function5<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5> fn1, Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)` Combine a 5-argument function returning a 6-tuple with a 6-parameter predicate into a 5-argument predicate.
`static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4,E5,E6> Predicate6<S1,S2,S3,S4,S5,S6>`	`concatPred6(Function6<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6> fn1, Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)` Combine a 6-argument function returning a 6-tuple with a 6-parameter predicate into a 6-argument predicate.
`static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4,E5,E6> Predicate7<S1,S2,S3,S4,S5,S6,S7>`	`concatPred7(Function7<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6,S7> fn1, Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)` Combine a 7-argument function returning a 6-tuple with a 6-parameter predicate into a 7-argument predicate.
`static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4,E5,E6> Predicate8<S1,S2,S3,S4,S5,S6,S7,S8>`	`concatPred8(Function8<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)` Combine a 8-argument function returning a 6-tuple with a 6-parameter predicate into a 8-argument predicate.
`static <S1,E1,E2,E3,E4,E5,E6> java.util.function.Consumer<S1>`	`concatProc1(java.util.function.Function<S1,? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>> fn1, Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)` Combine a 1-argument function returning a 6-tuple with a 6-parameter consumer/procedure into a 1-argument consumer/procedure.
`static <S1,S2,E1,E2,E3,E4,E5,E6> java.util.function.BiConsumer<S1,S2>`	`concatProc2(java.util.function.BiFunction<S1,S2,? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>> fn1, Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)` Combine a 2-argument function returning a 6-tuple with a 6-parameter consumer/procedure into a 2-argument consumer/procedure.
`static <S1,S2,S3,E1,E2,E3,E4,E5,E6> Procedure3<S1,S2,S3>`	`concatProc3(Function3<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3> fn1, Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)` Combine a 3-argument function returning a 6-tuple with a 6-parameter consumer/procedure into a 3-argument consumer/procedure.
`static <S1,S2,S3,S4,E1,E2,E3,E4,E5,E6> Procedure4<S1,S2,S3,S4>`	`concatProc4(Function4<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4> fn1, Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)` Combine a 4-argument function returning a 6-tuple with a 6-parameter consumer/procedure into a 4-argument consumer/procedure.
`static <S1,S2,S3,S4,S5,E1,E2,E3,E4,E5,E6> Procedure5<S1,S2,S3,S4,S5>`	`concatProc5(Function5<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5> fn1, Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)` Combine a 5-argument function returning a 6-tuple with a 6-parameter consumer/procedure into a 5-argument consumer/procedure.
`static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4,E5,E6> Procedure6<S1,S2,S3,S4,S5,S6>`	`concatProc6(Function6<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6> fn1, Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)` Combine a 6-argument function returning a 6-tuple with a 6-parameter consumer/procedure into a 6-argument consumer/procedure.
`static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4,E5,E6> Procedure7<S1,S2,S3,S4,S5,S6,S7>`	`concatProc7(Function7<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6,S7> fn1, Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)` Combine a 7-argument function returning a 6-tuple with a 6-parameter consumer/procedure into a 7-argument consumer/procedure.
`static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4,E5,E6> Procedure8<S1,S2,S3,S4,S5,S6,S7,S8>`	`concatProc8(Function8<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)` Combine a 8-argument function returning a 6-tuple with a 6-parameter consumer/procedure into a 8-argument consumer/procedure.
`static boolean`	`equals(ITuple6<?,?,?,?,?,?> tuple, java.lang.Object o)` Basic implementation of equals for 6-tuples.
`default NTuple6<T1,T2,T3,T4,T5,T6>`	`frozen()` Convert this into an object of a concrete tuple implementation.
`default Tuple6<T1,T2,T3,T4,T5,T6>`	`frozenNotNull()` Convert this into an object of a concrete tuple implementation.
`static int`	`hash(ITuple6<?,?,?,?,?,?> tuple)` Basic implementation for calculating a hash code of a 6-tuple.
`default <T> T`	`invoke(Function6<T,? super T1,? super T2,? super T3,? super T4,? super T5,? super T6> function)` Invoke a %d-argument function on this tuple.
`default void`	`sendTo(Procedure6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6> procedure)` Send this tuple unpacked to a 6-argument procedure.
`default boolean`	`testBy(Predicate6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6> predicate)` Test a 6-argument predicate with this tuple unpacked.
`static java.lang.String`	`toString(ITuple6<?,?,?,?,?,?> tuple)` Basic implementation for creating a string from a 6-tuple.
`static java.lang.String`	`toString(java.lang.String prefix, ITuple6<?,?,?,?,?,?> tuple)` Basic implementation for creating a string from a 6-tuple.
`static <E1,E2,E3,E4,E5,E6> ITuple6<E1,E2,E3,E4,E5,E6>`	`view(E1 elem1, E2 elem2, E3 elem3, E4 elem4, E5 elem5, E6 elem6)` Create a new 6-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
  - _5
```
T5 _5()
```
    Get the fifth element.
    
    Returns:
    
    fifth element
  - _6
```
T6 _6()
```
    Get the sixth element.
    
    Returns:
    
    sixth element
  - _12345
```
@NotNull
default ITuple5<T1,T2,T3,T4,T5> _12345()
```
    Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 4th, 5th.
    
    Returns:
    
    reordered tuple
  - _12346
```
@NotNull
default ITuple5<T1,T2,T3,T4,T6> _12346()
```
    Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 4th, 6th.
    
    Returns:
    
    reordered tuple
  - _12356
```
@NotNull
default ITuple5<T1,T2,T3,T5,T6> _12356()
```
    Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _12456
```
@NotNull
default ITuple5<T1,T2,T4,T5,T6> _12456()
```
    Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _13456
```
@NotNull
default ITuple5<T1,T3,T4,T5,T6> _13456()
```
    Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _23456
```
@NotNull
default ITuple5<T2,T3,T4,T5,T6> _23456()
```
    Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _1234
```
@NotNull
default ITuple4<T1,T2,T3,T4> _1234()
```
    Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 4th.
    
    Returns:
    
    reordered tuple
  - _1235
```
@NotNull
default ITuple4<T1,T2,T3,T5> _1235()
```
    Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 5th.
    
    Returns:
    
    reordered tuple
  - _1245
```
@NotNull
default ITuple4<T1,T2,T4,T5> _1245()
```
    Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 5th.
    
    Returns:
    
    reordered tuple
  - _1345
```
@NotNull
default ITuple4<T1,T3,T4,T5> _1345()
```
    Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 5th.
    
    Returns:
    
    reordered tuple
  - _2345
```
@NotNull
default ITuple4<T2,T3,T4,T5> _2345()
```
    Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 5th.
    
    Returns:
    
    reordered tuple
  - _1236
```
@NotNull
default ITuple4<T1,T2,T3,T6> _1236()
```
    Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 6th.
    
    Returns:
    
    reordered tuple
  - _1246
```
@NotNull
default ITuple4<T1,T2,T4,T6> _1246()
```
    Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 6th.
    
    Returns:
    
    reordered tuple
  - _1346
```
@NotNull
default ITuple4<T1,T3,T4,T6> _1346()
```
    Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 6th.
    
    Returns:
    
    reordered tuple
  - _2346
```
@NotNull
default ITuple4<T2,T3,T4,T6> _2346()
```
    Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 6th.
    
    Returns:
    
    reordered tuple
  - _1256
```
@NotNull
default ITuple4<T1,T2,T5,T6> _1256()
```
    Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _1356
```
@NotNull
default ITuple4<T1,T3,T5,T6> _1356()
```
    Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _2356
```
@NotNull
default ITuple4<T2,T3,T5,T6> _2356()
```
    Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _1456
```
@NotNull
default ITuple4<T1,T4,T5,T6> _1456()
```
    Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _2456
```
@NotNull
default ITuple4<T2,T4,T5,T6> _2456()
```
    Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _3456
```
@NotNull
default ITuple4<T3,T4,T5,T6> _3456()
```
    Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 5th, 6th.
    
    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
  - _125
```
@NotNull
default ITuple3<T1,T2,T5> _125()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 5th.
    
    Returns:
    
    reordered tuple
  - _152
```
@NotNull
default ITuple3<T1,T5,T2> _152()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 2nd.
    
    Returns:
    
    reordered tuple
  - _512
```
@NotNull
default ITuple3<T5,T1,T2> _512()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 2nd.
    
    Returns:
    
    reordered tuple
  - _521
```
@NotNull
default ITuple3<T5,T2,T1> _521()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 1st.
    
    Returns:
    
    reordered tuple
  - _251
```
@NotNull
default ITuple3<T2,T5,T1> _251()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 1st.
    
    Returns:
    
    reordered tuple
  - _215
```
@NotNull
default ITuple3<T2,T1,T5> _215()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 5th.
    
    Returns:
    
    reordered tuple
  - _135
```
@NotNull
default ITuple3<T1,T3,T5> _135()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 5th.
    
    Returns:
    
    reordered tuple
  - _153
```
@NotNull
default ITuple3<T1,T5,T3> _153()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 3rd.
    
    Returns:
    
    reordered tuple
  - _513
```
@NotNull
default ITuple3<T5,T1,T3> _513()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 3rd.
    
    Returns:
    
    reordered tuple
  - _531
```
@NotNull
default ITuple3<T5,T3,T1> _531()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 1st.
    
    Returns:
    
    reordered tuple
  - _351
```
@NotNull
default ITuple3<T3,T5,T1> _351()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 1st.
    
    Returns:
    
    reordered tuple
  - _315
```
@NotNull
default ITuple3<T3,T1,T5> _315()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 5th.
    
    Returns:
    
    reordered tuple
  - _235
```
@NotNull
default ITuple3<T2,T3,T5> _235()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 5th.
    
    Returns:
    
    reordered tuple
  - _253
```
@NotNull
default ITuple3<T2,T5,T3> _253()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 3rd.
    
    Returns:
    
    reordered tuple
  - _523
```
@NotNull
default ITuple3<T5,T2,T3> _523()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 3rd.
    
    Returns:
    
    reordered tuple
  - _532
```
@NotNull
default ITuple3<T5,T3,T2> _532()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 2nd.
    
    Returns:
    
    reordered tuple
  - _352
```
@NotNull
default ITuple3<T3,T5,T2> _352()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 2nd.
    
    Returns:
    
    reordered tuple
  - _325
```
@NotNull
default ITuple3<T3,T2,T5> _325()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 5th.
    
    Returns:
    
    reordered tuple
  - _145
```
@NotNull
default ITuple3<T1,T4,T5> _145()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 5th.
    
    Returns:
    
    reordered tuple
  - _154
```
@NotNull
default ITuple3<T1,T5,T4> _154()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 4th.
    
    Returns:
    
    reordered tuple
  - _514
```
@NotNull
default ITuple3<T5,T1,T4> _514()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 4th.
    
    Returns:
    
    reordered tuple
  - _541
```
@NotNull
default ITuple3<T5,T4,T1> _541()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 1st.
    
    Returns:
    
    reordered tuple
  - _451
```
@NotNull
default ITuple3<T4,T5,T1> _451()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 1st.
    
    Returns:
    
    reordered tuple
  - _415
```
@NotNull
default ITuple3<T4,T1,T5> _415()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 5th.
    
    Returns:
    
    reordered tuple
  - _245
```
@NotNull
default ITuple3<T2,T4,T5> _245()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 5th.
    
    Returns:
    
    reordered tuple
  - _254
```
@NotNull
default ITuple3<T2,T5,T4> _254()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 4th.
    
    Returns:
    
    reordered tuple
  - _524
```
@NotNull
default ITuple3<T5,T2,T4> _524()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 4th.
    
    Returns:
    
    reordered tuple
  - _542
```
@NotNull
default ITuple3<T5,T4,T2> _542()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 2nd.
    
    Returns:
    
    reordered tuple
  - _452
```
@NotNull
default ITuple3<T4,T5,T2> _452()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 2nd.
    
    Returns:
    
    reordered tuple
  - _425
```
@NotNull
default ITuple3<T4,T2,T5> _425()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 5th.
    
    Returns:
    
    reordered tuple
  - _345
```
@NotNull
default ITuple3<T3,T4,T5> _345()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 5th.
    
    Returns:
    
    reordered tuple
  - _354
```
@NotNull
default ITuple3<T3,T5,T4> _354()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 4th.
    
    Returns:
    
    reordered tuple
  - _534
```
@NotNull
default ITuple3<T5,T3,T4> _534()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 4th.
    
    Returns:
    
    reordered tuple
  - _543
```
@NotNull
default ITuple3<T5,T4,T3> _543()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 3rd.
    
    Returns:
    
    reordered tuple
  - _453
```
@NotNull
default ITuple3<T4,T5,T3> _453()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 3rd.
    
    Returns:
    
    reordered tuple
  - _435
```
@NotNull
default ITuple3<T4,T3,T5> _435()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 5th.
    
    Returns:
    
    reordered tuple
  - _126
```
@NotNull
default ITuple3<T1,T2,T6> _126()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 6th.
    
    Returns:
    
    reordered tuple
  - _162
```
@NotNull
default ITuple3<T1,T6,T2> _162()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 2nd.
    
    Returns:
    
    reordered tuple
  - _612
```
@NotNull
default ITuple3<T6,T1,T2> _612()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 2nd.
    
    Returns:
    
    reordered tuple
  - _621
```
@NotNull
default ITuple3<T6,T2,T1> _621()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 1st.
    
    Returns:
    
    reordered tuple
  - _261
```
@NotNull
default ITuple3<T2,T6,T1> _261()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 1st.
    
    Returns:
    
    reordered tuple
  - _216
```
@NotNull
default ITuple3<T2,T1,T6> _216()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 6th.
    
    Returns:
    
    reordered tuple
  - _136
```
@NotNull
default ITuple3<T1,T3,T6> _136()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 6th.
    
    Returns:
    
    reordered tuple
  - _163
```
@NotNull
default ITuple3<T1,T6,T3> _163()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 3rd.
    
    Returns:
    
    reordered tuple
  - _613
```
@NotNull
default ITuple3<T6,T1,T3> _613()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 3rd.
    
    Returns:
    
    reordered tuple
  - _631
```
@NotNull
default ITuple3<T6,T3,T1> _631()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 1st.
    
    Returns:
    
    reordered tuple
  - _361
```
@NotNull
default ITuple3<T3,T6,T1> _361()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 1st.
    
    Returns:
    
    reordered tuple
  - _316
```
@NotNull
default ITuple3<T3,T1,T6> _316()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 6th.
    
    Returns:
    
    reordered tuple
  - _236
```
@NotNull
default ITuple3<T2,T3,T6> _236()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 6th.
    
    Returns:
    
    reordered tuple
  - _263
```
@NotNull
default ITuple3<T2,T6,T3> _263()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 3rd.
    
    Returns:
    
    reordered tuple
  - _623
```
@NotNull
default ITuple3<T6,T2,T3> _623()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 3rd.
    
    Returns:
    
    reordered tuple
  - _632
```
@NotNull
default ITuple3<T6,T3,T2> _632()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 2nd.
    
    Returns:
    
    reordered tuple
  - _362
```
@NotNull
default ITuple3<T3,T6,T2> _362()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 2nd.
    
    Returns:
    
    reordered tuple
  - _326
```
@NotNull
default ITuple3<T3,T2,T6> _326()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 6th.
    
    Returns:
    
    reordered tuple
  - _146
```
@NotNull
default ITuple3<T1,T4,T6> _146()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 6th.
    
    Returns:
    
    reordered tuple
  - _164
```
@NotNull
default ITuple3<T1,T6,T4> _164()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 4th.
    
    Returns:
    
    reordered tuple
  - _614
```
@NotNull
default ITuple3<T6,T1,T4> _614()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 4th.
    
    Returns:
    
    reordered tuple
  - _641
```
@NotNull
default ITuple3<T6,T4,T1> _641()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 1st.
    
    Returns:
    
    reordered tuple
  - _461
```
@NotNull
default ITuple3<T4,T6,T1> _461()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 1st.
    
    Returns:
    
    reordered tuple
  - _416
```
@NotNull
default ITuple3<T4,T1,T6> _416()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 6th.
    
    Returns:
    
    reordered tuple
  - _246
```
@NotNull
default ITuple3<T2,T4,T6> _246()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 6th.
    
    Returns:
    
    reordered tuple
  - _264
```
@NotNull
default ITuple3<T2,T6,T4> _264()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 4th.
    
    Returns:
    
    reordered tuple
  - _624
```
@NotNull
default ITuple3<T6,T2,T4> _624()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 4th.
    
    Returns:
    
    reordered tuple
  - _642
```
@NotNull
default ITuple3<T6,T4,T2> _642()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 2nd.
    
    Returns:
    
    reordered tuple
  - _462
```
@NotNull
default ITuple3<T4,T6,T2> _462()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 2nd.
    
    Returns:
    
    reordered tuple
  - _426
```
@NotNull
default ITuple3<T4,T2,T6> _426()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 6th.
    
    Returns:
    
    reordered tuple
  - _346
```
@NotNull
default ITuple3<T3,T4,T6> _346()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 6th.
    
    Returns:
    
    reordered tuple
  - _364
```
@NotNull
default ITuple3<T3,T6,T4> _364()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 4th.
    
    Returns:
    
    reordered tuple
  - _634
```
@NotNull
default ITuple3<T6,T3,T4> _634()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 4th.
    
    Returns:
    
    reordered tuple
  - _643
```
@NotNull
default ITuple3<T6,T4,T3> _643()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 3rd.
    
    Returns:
    
    reordered tuple
  - _463
```
@NotNull
default ITuple3<T4,T6,T3> _463()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 3rd.
    
    Returns:
    
    reordered tuple
  - _436
```
@NotNull
default ITuple3<T4,T3,T6> _436()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 6th.
    
    Returns:
    
    reordered tuple
  - _156
```
@NotNull
default ITuple3<T1,T5,T6> _156()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _165
```
@NotNull
default ITuple3<T1,T6,T5> _165()
```
    Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 5th.
    
    Returns:
    
    reordered tuple
  - _615
```
@NotNull
default ITuple3<T6,T1,T5> _615()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 5th.
    
    Returns:
    
    reordered tuple
  - _651
```
@NotNull
default ITuple3<T6,T5,T1> _651()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 1st.
    
    Returns:
    
    reordered tuple
  - _561
```
@NotNull
default ITuple3<T5,T6,T1> _561()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 1st.
    
    Returns:
    
    reordered tuple
  - _516
```
@NotNull
default ITuple3<T5,T1,T6> _516()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 6th.
    
    Returns:
    
    reordered tuple
  - _256
```
@NotNull
default ITuple3<T2,T5,T6> _256()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _265
```
@NotNull
default ITuple3<T2,T6,T5> _265()
```
    Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 5th.
    
    Returns:
    
    reordered tuple
  - _625
```
@NotNull
default ITuple3<T6,T2,T5> _625()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 5th.
    
    Returns:
    
    reordered tuple
  - _652
```
@NotNull
default ITuple3<T6,T5,T2> _652()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 2nd.
    
    Returns:
    
    reordered tuple
  - _562
```
@NotNull
default ITuple3<T5,T6,T2> _562()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 2nd.
    
    Returns:
    
    reordered tuple
  - _526
```
@NotNull
default ITuple3<T5,T2,T6> _526()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 6th.
    
    Returns:
    
    reordered tuple
  - _356
```
@NotNull
default ITuple3<T3,T5,T6> _356()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _365
```
@NotNull
default ITuple3<T3,T6,T5> _365()
```
    Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 5th.
    
    Returns:
    
    reordered tuple
  - _635
```
@NotNull
default ITuple3<T6,T3,T5> _635()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 5th.
    
    Returns:
    
    reordered tuple
  - _653
```
@NotNull
default ITuple3<T6,T5,T3> _653()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 3rd.
    
    Returns:
    
    reordered tuple
  - _563
```
@NotNull
default ITuple3<T5,T6,T3> _563()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 3rd.
    
    Returns:
    
    reordered tuple
  - _536
```
@NotNull
default ITuple3<T5,T3,T6> _536()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 6th.
    
    Returns:
    
    reordered tuple
  - _456
```
@NotNull
default ITuple3<T4,T5,T6> _456()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _465
```
@NotNull
default ITuple3<T4,T6,T5> _465()
```
    Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 5th.
    
    Returns:
    
    reordered tuple
  - _645
```
@NotNull
default ITuple3<T6,T4,T5> _645()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 5th.
    
    Returns:
    
    reordered tuple
  - _654
```
@NotNull
default ITuple3<T6,T5,T4> _654()
```
    Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 4th.
    
    Returns:
    
    reordered tuple
  - _564
```
@NotNull
default ITuple3<T5,T6,T4> _564()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 4th.
    
    Returns:
    
    reordered tuple
  - _546
```
@NotNull
default ITuple3<T5,T4,T6> _546()
```
    Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 6th.
    
    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
  - _15
```
@NotNull
default ITuple2<T1,T5> _15()
```
    Create a new 2-tuple from this one where the elements are ordered: 1st, 5th.
    
    Returns:
    
    reordered tuple
  - _51
```
@NotNull
default ITuple2<T5,T1> _51()
```
    Create a new 2-tuple from this one where the elements are ordered: 5th, 1st.
    
    Returns:
    
    reordered tuple
  - _25
```
@NotNull
default ITuple2<T2,T5> _25()
```
    Create a new 2-tuple from this one where the elements are ordered: 2nd, 5th.
    
    Returns:
    
    reordered tuple
  - _52
```
@NotNull
default ITuple2<T5,T2> _52()
```
    Create a new 2-tuple from this one where the elements are ordered: 5th, 2nd.
    
    Returns:
    
    reordered tuple
  - _35
```
@NotNull
default ITuple2<T3,T5> _35()
```
    Create a new 2-tuple from this one where the elements are ordered: 3rd, 5th.
    
    Returns:
    
    reordered tuple
  - _53
```
@NotNull
default ITuple2<T5,T3> _53()
```
    Create a new 2-tuple from this one where the elements are ordered: 5th, 3rd.
    
    Returns:
    
    reordered tuple
  - _45
```
@NotNull
default ITuple2<T4,T5> _45()
```
    Create a new 2-tuple from this one where the elements are ordered: 4th, 5th.
    
    Returns:
    
    reordered tuple
  - _54
```
@NotNull
default ITuple2<T5,T4> _54()
```
    Create a new 2-tuple from this one where the elements are ordered: 5th, 4th.
    
    Returns:
    
    reordered tuple
  - _16
```
@NotNull
default ITuple2<T1,T6> _16()
```
    Create a new 2-tuple from this one where the elements are ordered: 1st, 6th.
    
    Returns:
    
    reordered tuple
  - _61
```
@NotNull
default ITuple2<T6,T1> _61()
```
    Create a new 2-tuple from this one where the elements are ordered: 6th, 1st.
    
    Returns:
    
    reordered tuple
  - _26
```
@NotNull
default ITuple2<T2,T6> _26()
```
    Create a new 2-tuple from this one where the elements are ordered: 2nd, 6th.
    
    Returns:
    
    reordered tuple
  - _62
```
@NotNull
default ITuple2<T6,T2> _62()
```
    Create a new 2-tuple from this one where the elements are ordered: 6th, 2nd.
    
    Returns:
    
    reordered tuple
  - _36
```
@NotNull
default ITuple2<T3,T6> _36()
```
    Create a new 2-tuple from this one where the elements are ordered: 3rd, 6th.
    
    Returns:
    
    reordered tuple
  - _63
```
@NotNull
default ITuple2<T6,T3> _63()
```
    Create a new 2-tuple from this one where the elements are ordered: 6th, 3rd.
    
    Returns:
    
    reordered tuple
  - _46
```
@NotNull
default ITuple2<T4,T6> _46()
```
    Create a new 2-tuple from this one where the elements are ordered: 4th, 6th.
    
    Returns:
    
    reordered tuple
  - _64
```
@NotNull
default ITuple2<T6,T4> _64()
```
    Create a new 2-tuple from this one where the elements are ordered: 6th, 4th.
    
    Returns:
    
    reordered tuple
  - _56
```
@NotNull
default ITuple2<T5,T6> _56()
```
    Create a new 2-tuple from this one where the elements are ordered: 5th, 6th.
    
    Returns:
    
    reordered tuple
  - _65
```
@NotNull
default ITuple2<T6,T5> _65()
```
    Create a new 2-tuple from this one where the elements are ordered: 6th, 5th.
    
    Returns:
    
    reordered tuple
  - asBase
```
@NotNull
default ITuple6.Base<T1,T2,T3,T4,T5,T6> asBase()
```
    Convert this 6-tuple into a base tuple which provides useful implementations for standard methods.
    
    Returns:
    
    base view of this tuple
  - frozen
```
@NotNull
default NTuple6<T1,T2,T3,T4,T5,T6> 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 Tuple6<T1,T2,T3,T4,T5,T6> 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
                     Function6<T,? super T1,? super T2,? super T3,? super T4,? super T5,? super T6> 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
                    Procedure6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6> procedure)
```
    Send this tuple unpacked to a 6-argument procedure.
    
    Parameters:
    
    procedure - procedure called with the unpacked elements of this tuple
  - testBy
```
default boolean testBy(@NotNull
                       Predicate6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6> predicate)
```
    Test a 6-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,E5,E6> ITuple6<E1,E2,E3,E4,E5,E6> view(E1 elem1,
                                                                    E2 elem2,
                                                                    E3 elem3,
                                                                    E4 elem4,
                                                                    E5 elem5,
                                                                    E6 elem6)
```
    Create a new 6-tuple on the fly. This is especially useful for temporary usage, you might want to create a Tuple6 instead as that gives guarantees of the non-nullness of its elements, or a NTuple6 as that at least is serializable (as is Tuple6).
    
    Type Parameters:
    
    E1 - type of first element
    
    E2 - type of second element
    
    E3 - type of third element
    
    E4 - type of fourth element
    
    E5 - type of fifth element
    
    E6 - type of sixth 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
    
    elem5 - fifth element of returned tuple
    
    elem6 - sixth element of returned tuple
    
    Returns:
    
    6-tuple view of the given elements
  - equals
```
static boolean equals(@NotNull
                      ITuple6<?,?,?,?,?,?> tuple,
                      @Nullable
                      java.lang.Object o)
```
    Basic implementation of equals for 6-tuples. This can be used in implementations to implement Object.equals(Object). Don't forget hashing: hash(ITuple6)
    
    Parameters:
    
    tuple - tuple to compare
    
    o - other object to compare
    
    Returns:
    
    false if o is null, not a ITuple6, or its members differ
    true otherwise
  - hash
```
static int hash(@NotNull
                ITuple6<?,?,?,?,?,?> tuple)
```
    Basic implementation for calculating a hash code of a 6-tuple. This can be used in implementations to implement Object.hashCode(). Don't forget equals: equals(ITuple6, Object).
    
    Parameters:
    
    tuple - tuple to hash
    
    Returns:
    
    hash code
  - toString
```
@NotNull
static java.lang.String toString(@NotNull
                                          ITuple6<?,?,?,?,?,?> tuple)
```
    Basic implementation for creating a string from a 6-tuple. This one uses "ITuple6" as prefix. This can be used im implementations to implement Object.toString().
    
    Parameters:
    
    tuple - tuple to convert
    
    Returns:
    
    text form
    
    See Also:
    
    toString(String, ITuple6)
  - toString
```
@NotNull
static java.lang.String toString(@NotNull
                                          java.lang.String prefix,
                                          @NotNull
                                          ITuple6<?,?,?,?,?,?> tuple)
```
    Basic implementation for creating a string from a 6-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(ITuple6)
  - concat1
```
@NotNull
static <S1,E1,E2,E3,E4,E5,E6,R> java.util.function.Function<S1,R> concat1(@NotNull
                                                                                   java.util.function.Function<S1,? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>> fn1,
                                                                                   @NotNull
                                                                                   Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)
```
    Combine a 1-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    R - result type
    
    Parameters:
    
    fn1 - 1-argument function returning a 6-tuple
    
    fn2 - 6-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,E5,E6> java.util.function.Consumer<S1> concatProc1(@NotNull
                                                                                   java.util.function.Function<S1,? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>> fn1,
                                                                                   @NotNull
                                                                                   Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)
```
    Combine a 1-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 1-argument function returning a 6-tuple
    
    proc2 - 6-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,E5,E6> java.util.function.Predicate<S1> concatPred1(@NotNull
                                                                                    java.util.function.Function<S1,? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>> fn1,
                                                                                    @NotNull
                                                                                    Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)
```
    Combine a 1-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 1-argument function returning a 6-tuple
    
    pred2 - 6-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,E5,E6,R> java.util.function.BiFunction<S1,S2,R> concat2(@NotNull
                                                                                           java.util.function.BiFunction<S1,S2,? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>> fn1,
                                                                                           @NotNull
                                                                                           Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)
```
    Combine a 2-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    R - result type
    
    Parameters:
    
    fn1 - 2-argument function returning a 6-tuple
    
    fn2 - 6-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,E5,E6> java.util.function.BiConsumer<S1,S2> concatProc2(@NotNull
                                                                                           java.util.function.BiFunction<S1,S2,? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>> fn1,
                                                                                           @NotNull
                                                                                           Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)
```
    Combine a 2-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 2-argument function returning a 6-tuple
    
    proc2 - 6-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,E5,E6> java.util.function.BiPredicate<S1,S2> concatPred2(@NotNull
                                                                                            java.util.function.BiFunction<S1,S2,? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>> fn1,
                                                                                            @NotNull
                                                                                            Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)
```
    Combine a 2-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 2-argument function returning a 6-tuple
    
    pred2 - 6-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,E5,E6,R> Function3<R,S1,S2,S3> concat3(@NotNull
                                                                             Function3<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3> fn1,
                                                                             @NotNull
                                                                             Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)
```
    Combine a 3-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    R - result type
    
    Parameters:
    
    fn1 - 3-argument function returning a 6-tuple
    
    fn2 - 6-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,E5,E6> Procedure3<S1,S2,S3> concatProc3(@NotNull
                                                                              Function3<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3> fn1,
                                                                              @NotNull
                                                                              Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)
```
    Combine a 3-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 3-argument function returning a 6-tuple
    
    proc2 - 6-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,E5,E6> Predicate3<S1,S2,S3> concatPred3(@NotNull
                                                                              Function3<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3> fn1,
                                                                              @NotNull
                                                                              Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)
```
    Combine a 3-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 3-argument function returning a 6-tuple
    
    pred2 - 6-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,E5,E6,R> Function4<R,S1,S2,S3,S4> concat4(@NotNull
                                                                                   Function4<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4> fn1,
                                                                                   @NotNull
                                                                                   Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)
```
    Combine a 4-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    R - result type
    
    Parameters:
    
    fn1 - 4-argument function returning a 6-tuple
    
    fn2 - 6-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,E5,E6> Procedure4<S1,S2,S3,S4> concatProc4(@NotNull
                                                                                    Function4<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4> fn1,
                                                                                    @NotNull
                                                                                    Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)
```
    Combine a 4-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 4-argument function returning a 6-tuple
    
    proc2 - 6-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,E5,E6> Predicate4<S1,S2,S3,S4> concatPred4(@NotNull
                                                                                    Function4<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4> fn1,
                                                                                    @NotNull
                                                                                    Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)
```
    Combine a 4-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 4-argument function returning a 6-tuple
    
    pred2 - 6-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,E5,E6,R> Function5<R,S1,S2,S3,S4,S5> concat5(@NotNull
                                                                                         Function5<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5> fn1,
                                                                                         @NotNull
                                                                                         Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)
```
    Combine a 5-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    R - result type
    
    Parameters:
    
    fn1 - 5-argument function returning a 6-tuple
    
    fn2 - 6-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,E5,E6> Procedure5<S1,S2,S3,S4,S5> concatProc5(@NotNull
                                                                                          Function5<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5> fn1,
                                                                                          @NotNull
                                                                                          Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)
```
    Combine a 5-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 5-argument function returning a 6-tuple
    
    proc2 - 6-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,E5,E6> Predicate5<S1,S2,S3,S4,S5> concatPred5(@NotNull
                                                                                          Function5<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5> fn1,
                                                                                          @NotNull
                                                                                          Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)
```
    Combine a 5-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 5-argument function returning a 6-tuple
    
    pred2 - 6-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,E5,E6,R> Function6<R,S1,S2,S3,S4,S5,S6> concat6(@NotNull
                                                                                               Function6<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6> fn1,
                                                                                               @NotNull
                                                                                               Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)
```
    Combine a 6-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    R - result type
    
    Parameters:
    
    fn1 - 6-argument function returning a 6-tuple
    
    fn2 - 6-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,E5,E6> Procedure6<S1,S2,S3,S4,S5,S6> concatProc6(@NotNull
                                                                                                Function6<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6> fn1,
                                                                                                @NotNull
                                                                                                Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)
```
    Combine a 6-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 6-argument function returning a 6-tuple
    
    proc2 - 6-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,E5,E6> Predicate6<S1,S2,S3,S4,S5,S6> concatPred6(@NotNull
                                                                                                Function6<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6> fn1,
                                                                                                @NotNull
                                                                                                Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)
```
    Combine a 6-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 6-argument function returning a 6-tuple
    
    pred2 - 6-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,E5,E6,R> Function7<R,S1,S2,S3,S4,S5,S6,S7> concat7(@NotNull
                                                                                                     Function7<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6,S7> fn1,
                                                                                                     @NotNull
                                                                                                     Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)
```
    Combine a 7-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    R - result type
    
    Parameters:
    
    fn1 - 7-argument function returning a 6-tuple
    
    fn2 - 6-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,E5,E6> Procedure7<S1,S2,S3,S4,S5,S6,S7> concatProc7(@NotNull
                                                                                                      Function7<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6,S7> fn1,
                                                                                                      @NotNull
                                                                                                      Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)
```
    Combine a 7-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 7-argument function returning a 6-tuple
    
    proc2 - 6-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,E5,E6> Predicate7<S1,S2,S3,S4,S5,S6,S7> concatPred7(@NotNull
                                                                                                      Function7<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6,S7> fn1,
                                                                                                      @NotNull
                                                                                                      Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)
```
    Combine a 7-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 7-argument function returning a 6-tuple
    
    pred2 - 6-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,E5,E6,R> Function8<R,S1,S2,S3,S4,S5,S6,S7,S8> concat8(@NotNull
                                                                                                           Function8<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
                                                                                                           @NotNull
                                                                                                           Function6<R,? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> fn2)
```
    Combine a 8-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    R - result type
    
    Parameters:
    
    fn1 - 8-argument function returning a 6-tuple
    
    fn2 - 6-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,E5,E6> Procedure8<S1,S2,S3,S4,S5,S6,S7,S8> concatProc8(@NotNull
                                                                                                            Function8<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
                                                                                                            @NotNull
                                                                                                            Procedure6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> proc2)
```
    Combine a 8-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 8-argument function returning a 6-tuple
    
    proc2 - 6-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,E5,E6> Predicate8<S1,S2,S3,S4,S5,S6,S7,S8> concatPred8(@NotNull
                                                                                                            Function8<? extends ITuple6<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5,? extends E6>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
                                                                                                            @NotNull
                                                                                                            Predicate6<? super E1,? super E2,? super E3,? super E4,? super E5,? super E6> pred2)
```
    Combine a 8-argument function returning a 6-tuple with a 6-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
    
    E5 - type of fifth element of intermediate tuple
    
    E6 - type of sixth element of intermediate tuple
    
    Parameters:
    
    fn1 - 8-argument function returning a 6-tuple
    
    pred2 - 6-argument predicate which can use the expanded tuple elements as arguments
    
    Returns:
    
    8-argument predicate which returns the test result of the tuple returned by fn1

Interface ITuple6<T1,T2,T3,T4,T5,T6>

Nested Class Summary

Method Summary

Method Detail

_1

_2

_3

_4

_5

_6

_12345

_12346

_12356

_12456

_13456

_23456

_1234

_1235

_1245

_1345

_2345

_1236

_1246

_1346

_2346

_1256

_1356

_2356

_1456

_2456

_3456

_123

_132

_312

_321

_231

_213

_124

_142

_412

_421

_241

_214

_134

_143

_413

_431

_341

_314

_234

_243

_423

_432

_342

_324

_125

_152

_512

_521

_251

_215

_135

_153

_513

_531

_351

_315

_235

_253

_523

_532

_352

_325

_145

_154

_514

_541

_451

_415

_245